Skip to content

ROADMAP.md

Latest commit

 

History

History
328 lines (267 loc) · 8.11 KB

ROADMAP.md

File metadata and controls

328 lines (267 loc) · 8.11 KB

AutoHands Development Roadmap

Overview

The project is divided into 4 main phases, with an estimated total development cycle of 12-16 weeks.

Phase 1: Core Framework (4-5 weeks)
    ↓
Phase 2: Basic Extensions (3-4 weeks)
    ↓
Phase 3: Agent Runtime (3-4 weeks)
    ↓
Phase 4: Ecosystem Enhancement (2-3 weeks)

Phase 1: Core Framework (4-5 weeks)

Goal

Build an extensible core framework, define all protocols, and implement the microkernel.

Task List

1.1 Project Initialization

  • Create project directory structure
  • Create architecture documentation
  • Initialize Cargo workspace
  • Configure CI/CD (GitHub Actions)
  • Configure code quality tools (clippy, rustfmt)

1.2 autohands-protocols (Protocol Layer)

  • Extension trait definition
  • Tool trait definition
  • LLMProvider trait definition
  • Channel trait definition
  • MemoryBackend trait definition
  • Agent trait definition
  • Skill-related type definitions
  • Common type definitions (Message, ToolResult, etc.)
  • Error type definitions

1.3 autohands-core (Core Layer)

  • TaskQueue implementation
    • Task subscribe/publish
    • Middleware support
    • Request-response pattern
  • ExecutionContext implementation
    • Context data storage
    • Abort signal
    • Sub-context creation
  • ExtensionRegistry implementation
    • Extension registration/unregistration
    • Dependency resolution
  • ToolRegistry implementation
  • ProviderRegistry implementation
  • Kernel implementation
    • Extension lifecycle management
    • Extension context creation
    • Startup/shutdown process refinement

1.4 autohands-config (Configuration Layer)

  • Configuration schema definition
  • TOML configuration parsing
  • Environment variable substitution
  • Configuration validation
  • Configuration hot-reload (optional, Phase 4)

1.5 Unit Tests

  • protocols tests
  • core tests
  • config tests

Deliverables

  • Compilable core framework
  • Complete protocol definitions
  • Unit test coverage

Phase 2: Basic Extensions (3-4 weeks)

Goal

Implement basic tools and providers to validate the framework design.

Task List

2.1 autohands-macros (Procedural Macros)

  • #[extension] macro
  • #[tool] macro
  • Macro tests

2.2 tools-filesystem (Filesystem Tools)

  • read_file tool
  • write_file tool
  • edit_file tool (SEARCH/REPLACE)
  • list_directory tool
  • create_directory tool
  • delete_file tool
  • move_file tool
  • Tests

2.3 tools-shell (Shell Tools)

  • exec tool (command execution)
  • Persistent shell session
  • Background process management
  • Timeout control
  • Tests

2.4 tools-search (Search Tools)

  • glob tool (file pattern matching)
  • grep tool (content search)
  • Integrated ripgrep
  • Tests

2.5 provider-anthropic (Anthropic Provider)

  • API client implementation
  • Streaming completion
  • Function calling support
  • Error handling and retry
  • Tests

2.6 provider-openai (OpenAI Provider)

  • API client implementation
  • Streaming completion
  • Function calling support
  • Tests

2.7 provider-ark (Volcengine Ark Provider)

  • API client implementation
  • Streaming completion
  • Function calling support
  • Tests

2.8 memory-sqlite (SQLite Memory Backend)

  • Database schema
  • CRUD operations
  • Basic search
  • Tests

Deliverables

  • 7+ available tools (filesystem, shell, search)
  • 3 LLM Providers (Anthropic, OpenAI, Ark)
  • 1 memory backend
  • Extension development examples

Phase 3: Agent Runtime (3-4 weeks)

Goal

Implement complete Agent runtime and API gateway.

Task List

3.1 autohands-runtime (Runtime)

  • SessionManager implementation
    • Session creation/retrieval
    • Session persistence
    • Session cleanup
  • HistoryManager implementation
    • Message history management
    • History compression (summarization)
  • ContextBuilder implementation
    • System prompt construction
    • Tool injection
    • Skill injection
  • AgentLoop implementation
    • Main loop logic
    • Tool execution
    • Streaming response
    • Error handling and retry
    • Termination condition checking
  • AgentRuntime implementation
    • Agent scheduling
    • Concurrency control

3.2 autohands-api (API Server)

  • HTTP server (axum)
    • OpenAI compatible API
    • Health check endpoint
    • Admin endpoints
  • WebSocket server
    • Connection management
    • Message protocol
    • Heartbeat mechanism
  • RunLoopBridge
    • Request routing
    • Session association

3.3 autohands-runloop (RunLoop)

  • TaskQueue implementation
  • RunLoop implementation
  • Source0/Source1 patterns
  • Observer pattern
  • Timer support
  • CronTimer support

3.4 skills-dynamic (Dynamic Skills)

  • Skill loader implementation
  • Markdown parser
  • Progressive disclosure (L1/L2/L3)
  • Multiple format adapters (Claude Code, Microsoft, OpenClaw)
  • Skill injection logic

3.5 agent-general (General Agent)

  • General agent implementation
  • Tool selection logic
  • Tests

3.6 Integration Tests

  • End-to-end tests
  • API tests
  • Agent execution tests

Deliverables

  • Complete runnable Agent system
  • HTTP/WebSocket API
  • General Agent
  • Dynamic skills

Phase 4: Ecosystem Enhancement (2-3 weeks)

Goal

Enhance ecosystem, improve usability and extensibility.

Task List

4.1 More Providers

  • provider-gemini (Google Gemini)
  • provider-local (Local models/Ollama)

4.2 More Tools

  • tools-web
    • web_fetch tool
    • web_search tool
  • tools-code
    • Code analysis tools
    • LSP integration (optional)
  • tools-browser
    • Browser automation (CDP)
    • AI-powered click/fill/extract
  • tools-desktop
    • Screenshot
    • Mouse control
    • Keyboard control
    • OCR

4.3 Channel Support

  • channel-telegram (Telegram channel, optional)

4.4 MCP Support

  • MCP protocol bridge (planned)

4.5 Vector Memory

  • memory-vector
    • Embedding generation
    • Vector storage
    • Hybrid search
  • memory-hybrid
    • Full-text search
    • Vector search
    • Fusion ranking

4.6 Daemon Support

  • autohands-daemon
    • Process daemonization
    • PID file management
    • Signal handling
    • macOS LaunchAgent support
    • Linux Systemd support

4.7 Documentation and Examples

  • API documentation
  • Architecture documentation
  • Extension development guide
  • Example projects

4.8 Performance Optimization

  • Benchmark tests
  • Performance analysis and optimization
  • Memory optimization

Deliverables

  • 4 Providers
  • 46+ Tools
  • MCP support
  • Daemon support
  • Complete documentation

Milestones

Milestone Target Date Content
M1: Core Framework Week 4-5 Protocol definitions, microkernel, configuration
M2: Basic Usable Week 7-9 Basic tools, providers, agent
M3: Feature Complete Week 10-12 API server, skills, channels
M4: Production Ready Week 12-16 MCP, optimization, documentation

Risks and Mitigation

Risk Impact Mitigation
Long Rust compilation time Development efficiency Use incremental compilation, mold linker
Missing MCP SDK Development cycle Implement protocol ourselves
Complex extension system Delay Initially only implement static extensions
LLM API changes Compatibility Abstraction layer isolation

Development Principles

  1. Test-Driven - Write tests first, then implementation
  2. Documentation in Sync - Update code and documentation together
  3. Small Iterations - Each PR focuses on a single feature
  4. Code Review - All code requires review
  5. Performance Awareness - Focus on performance, avoid premature optimization

Last Updated: 2026-02-09