Product Roadmap

Product Roadmap

Aden Agent Framework aims to help developers build outcome-oriented, self-adaptive agents. Please find our roadmap here

flowchart TB
    %% Main Entity
    User([User])

    %% =========================================
    %% EXTERNAL EVENT SOURCES
    %% =========================================
    subgraph ExtEventSource [External Event Source]
        E_Sch["Schedulers"]
        E_WH["Webhook"]
        E_SSE["SSE"]
    end

    %% =========================================
    %% SYSTEM NODES
    %% =========================================
    subgraph WorkerBees [Worker Bees]
        WB_C["Conversation"]
        WB_SP["System prompt"]

        subgraph Graph [Graph]
            direction TB
            N1["Node"] --> N2["Node"] --> N3["Node"]
            N1 -.-> AN["Active Node"]
            N2 -.-> AN
            N3 -.-> AN

            %% Nested Event Loop Node
            subgraph EventLoopNode [Event Loop Node]
                ELN_L["listener"]
                ELN_SP["System Prompt<br/>(Task)"]
                ELN_EL["Event loop"]
                ELN_C["Conversation"]
            end
        end
    end

    subgraph JudgeNode [Judge]
        J_C["Criteria"]
        J_P["Principles"]
        J_EL["Event loop"] <--> J_S["Scheduler"]
    end

    subgraph QueenBee [Queen Bee]
        QB_SP["System prompt"]
        QB_EL["Event loop"]
        QB_C["Conversation"]
    end

    subgraph Infra [Infra]
        SA["Sub Agent"]
        TR["Tool Registry"]
        WTM["Write through Conversation Memory<br/>(Logs/RAM/Harddrive)"]
        SM["Shared Memory<br/>(State/Harddrive)"]
        EB["Event Bus<br/>(RAM)"]
        CS["Credential Store<br/>(Harddrive/Cloud)"]
    end

    subgraph PC [PC]
        B["Browser"]
        CB["Codebase<br/>v 0.0.x ... v n.n.n"]
    end

    %% =========================================
    %% CONNECTIONS & DATA FLOW
    %% =========================================

    %% External Event Routing
    E_Sch --> ELN_L
    E_WH --> ELN_L
    E_SSE --> ELN_L
    ELN_L -->|"triggers"| ELN_EL

    %% User Interactions
    User -->|"Talk"| WB_C
    User -->|"Talk"| QB_C
    User -->|"Read/Write Access"| CS

    %% Inter-System Logic
    ELN_C <-->|"Mirror"| WB_C
    WB_C -->|"Focus"| AN

    WorkerBees -->|"Inquire"| JudgeNode
    JudgeNode -->|"Approve"| WorkerBees

    %% Judge Alignments
    J_C <-.->|"aligns"| WB_SP
    J_P <-.->|"aligns"| QB_SP

    %% Escalate path
    J_EL -->|"Report (Escalate)"| QB_EL

    %% Pub/Sub Logic
    AN -->|"publish"| EB
    EB -->|"subscribe"| QB_C

    %% Infra and Process Spawning
    ELN_EL -->|"Spawn"| SA
    SA -->|"Inform"| ELN_EL
    SA -->|"Starts"| B
    B -->|"Report"| ELN_EL
    TR -->|"Assigned"| EventLoopNode
    CB -->|"Modify Worker Bee"| WorkerBees

    %% =========================================
    %% SHARED MEMORY & LOGS ACCESS
    %% =========================================

    %% Worker Bees Access
    Graph <-->|"Read/Write"| WTM
    Graph <-->|"Read/Write"| SM

    %% Queen Bee Access
    QB_C <-->|"Read/Write"| WTM
    QB_EL <-->|"Read/Write"| SM

    %% Credentials Access
    CS -->|"Read Access"| QB_C

Core Architecture & Swarm Primitives

Node-Based Architecture

Implement the core execution engine where every Agent operates as an isolated, asynchronous graph of nodes.

• Core Node Implementation
  • NodeProtocol with JSON parsing utilities (graph/node.py)
  • EventLoopNode with LLM conversation management (graph/event_loop_node.py)
  • Flexible input/output keys with nullable output handling
  • Node wrapper SDK for agent creation
  • Tool access layer with MCP integration
• Graph Executor
  • Graph traversal execution (graph/executor.py)
  • Node transition management
  • Error handling and output mapping
  • ExecutionResult with success/error status
• Shared Memory Access
  • SharedState manager (runtime/shared_state.py)
  • Session-based storage (storage/session_store.py)
  • Isolation levels: ISOLATED, SHARED, SYNCHRONIZED
• Default Monitoring Hooks
  • Performance metrics collection
  • Resource usage tracking
  • Health check endpoints

Node Protocol

Build the standard communication protocol for inter-node messaging and data passing.

• Edge Specifications
  • ALWAYS: Always traverse (graph/edge.py)
  • ON_SUCCESS: Success-based routing
  • ON_FAILURE: Failure-based routing
  • CONDITIONAL: Expression-based routing with safe_eval
  • LLM_DECIDE: Goal-aware LLM-powered routing
• Event Bus System
  • Full event bus implementation (runtime/event_bus.py)
  • LLM text deltas, tool calls, node transitions
  • Graph-scoped event routing for multi-agent scenarios
• Conversation Management
  • NodeConversation tracks message history (graph/conversation.py)
  • Tool results, streaming content, metadata support

Judge in Event Loop

A separate LLM-powered judge to determine if the workers finish their job.

• Conversation Judge (Level 2)
  • Evaluates node completion against success criteria (graph/conversation_judge.py)
  • Reads recent conversation and assesses quality
  • Returns verdict: ACCEPT or RETRY with confidence scores
• Test Evaluation Judge
  • Provider-agnostic (OpenAI, Anthropic, Google Gemini) (testing/llm_judge.py)
  • JSON response parsing for structured evaluation
• Multi-Level Judgment Integration
  • Judge node integration with event loop
  • Automatic retry logic based on judge verdict
  • Judge performance monitoring

Swarm Hierarchy

Develop the distinct behavioral logic for the Queen Bee (Orchestrator), Judge Bee (Evaluator), and Worker Bee (Executor).

• Judge Bee (Evaluator)
  • Evaluation criteria framework (graph/goal.py)
  • Success/failure determination
  • Quality assessment with confidence scores
• Hive Coder Agent (Builder)
  • Coder node: forever-alive event loop (agents/hive_coder/nodes/)
  • Guardian node: event-driven watchdog for supervised agents
  • Tool discovery (discover_mcp_tools)
  • Agent aware (list_agents, inspect sessions)
  • Post-build testing (run_agent_tests)
  • Debugging capabilities (inspect checkpoints, memory)
• Queen Bee (Orchestrator)
  • Multi-agent coordination layer
  • Task distribution logic
  • Dynamic worker agent creation
  • Swarm-level goal management
• Worker Bee (Executor)
  • Worker taxonomy definition
  • Worker agent templates
  • Task execution patterns

Coding Agent Workflows

Implement the Goal Creation Session via the Queen Bee and the dynamic Worker Agent Creation flow.

• Goal Creation Session
  • Goal object schema definition (graph/goal.py)
  • SuccessCriterion: Measurable success (5+ criteria per goal)
  • Constraint: Hard/soft boundaries (time, cost, safety, scope, quality)
  • GoalStatus: DRAFT → READY → ACTIVE → COMPLETED/FAILED
  • Instruction back and forth in Hive Coder
  • Test case generation
  • Test case validation for worker agent
• Agent Creation Flow
  • Hive Coder reads templates and discovers tools (mcp/agent_builder_server.py)
  • Generates agent.py, nodes/init.py, config.py
  • MCP server configuration discovery
  • Dynamic tool binding
• Worker Agent Dynamic Creation
  • Template agent initialization from Queen Bee
  • Runtime worker instantiation
  • Worker lifecycle management

Security Layer

Build robust, local Credential Management interfaces for secure API key handling.

• Unified Credential Store
  • Multi-backend storage (credentials/store.py)
  • EncryptedFileStorage: Encrypted local storage (~/.hive/credentials)
  • EnvVarStorage: Environment variable mapping
  • InMemoryStorage: Testing
  • HashiCorp Vault: Enterprise secrets (credentials/storage.py)
  • Template resolution: {{cred.key}} patterns
  • Caching with TTL (default 5 min, configurable)
  • Thread-safe operations with RLock
• OAuth2 Providers
  • Base provider pattern (credentials/oauth2/)
  • HubSpot provider integration
  • Lifecycle management (refresh tokens)
  • Browser opening for auth flows (tools/credentials/browser.py)
• Aden Sync Provider
  • Syncs OAuth2 tokens from Aden authentication server (credentials/aden/)
  • Falls back to local storage if Aden unavailable
  • Auto-refresh on sync
• Enterprise Secret Managers
  • AWS Secrets Manager integration
  • Azure Key Vault integration
  • Audit logging for compliance/tracking
  • Per-environment configuration support

Tooling Ecosystem & General Compute

Sub-agents Parallel Execution

Develop the Sub-agent execution environment for parallel tasks execution. The subagents are designed with isolation for repeatability.

• Multi-Graph Sessions
  • Load multiple agent graphs in single session (runtime/agent_runtime.py)
  • Shared state between graphs
  • Independent execution streams
  • Graph lifecycle management (load/unload/start/restart)
• Concurrent Execution Management
  • Max concurrent executions configuration
  • Isolation levels: isolated, shared, synchronized
• Sub-agent Execution Environment
  • Isolated sub-agent runtime environment
  • Task isolation mechanisms
  • Result aggregation
  • Error handling for parallel tasks
  • Repeatability guarantees

Browser Use Node

Implement native browser-integrated automation so agents can take over a browser for auth and agents perform the automation jobs. This node comes with a specific set of tools and system prompts.

• Web Scraping with Playwright
  • Headless Chromium launch (tools/web_scrape_tool/)
  • Stealth mode via playwright_stealth
  • JavaScript rendering with wait-for-domcontentloaded
  • CSS selector support
  • User-agent spoofing
  • Sandbox/automation detection evasion
• Browser Launch Utilities
  • Platform-specific browser opening (macOS/Linux/Windows) (tools/credentials/browser.py)
  • OAuth2 flow integration
• Full Browser Use Node
  • Multi-page automation workflows
  • Form filling with vision-guided interactions
  • Interactive screenshot capabilities
  • Session management across navigations
  • Browser-specific tool set
  • System prompts for browser tasks

Core Graph Framework Infra

Ship essential framework utilities: Node validation, HITL (Human-in-the-loop pause/approve), and node lifecycle management.

• Node Validation
  • Pydantic-based validation
  • Schema enforcement
  • Output key validation (Level 0)
• Human-in-the-Loop (HITL)
  • HITLRequest and HITLResponse protocol (graph/hitl.py)
  • Question types: FREE_TEXT, STRUCTURED, SELECTION, APPROVAL, MULTI_FIELD
  • Haiku-powered response parsing
  • User-friendly display formatting
  • Pause/approve workflow
  • State saved to checkpoint
  • Resume with HITLResponse merged into context
• TUI Integration
  • Chat REPL with streaming support (tui/app.py)
  • Multi-graph session management
  • User presence detection
  • Real-time log viewing
• Node Lifecycle Management
  • Start/stop/pause/resume in execution stream
  • State persistence via checkpoint store
  • Recovery mechanisms with checkpoint restore
• Advanced HITL Features
  • Callback handlers for custom intervention logic
  • Streaming interface for real-time monitoring
  • Approval workflows at scale

Infrastructure Tools

Port popular tools, and build out the Runtime Log, Audit Trail, Excel, and Email integrations.

• File Operations (36+ tools)
  • read_file, write_file, edit_file (mcp/agent_builder_server.py)
  • list_directory, search_files
  • apply_diff / apply_patch for code modification (tools/file_system_toolkits/)
  • data_tools (CSV/Excel parsing)
• Web Tools
  • Web Search (tools/web_search_tool/)
  • Web Scraper (tools/web_scrape_tool/)
  • Exa Search (tools/exa_search_tool/)
  • News Tool (tools/news_tool/)
  • SerpAPI (tools/serpapi_tool/)
• Data Tools
  • CSV tools (tools/csv_tool/)
  • Excel tools (tools/excel_tool/)
  • PDF tools (tools/pdf_read_tool/)
  • Vision tool for image analysis (tools/vision_tool/)
  • Time tool (tools/time_tool/)
• Communication Tools (8 tools)
  • Email tool (tools/email_tool/)
  • Gmail tool (tools/gmail_tool/)
  • Slack tool (tools/slack_tool/)
  • Discord tool (tools/discord_tool/)
  • Telegram tool (tools/telegram_tool/)
  • Google Docs (tools/google_docs_tool/)
  • Google Maps (tools/google_maps_tool/)
  • Cal.com (tools/calcom_tool/)
• CRM/API Integrations (5+ tools)
  • HubSpot (tools/hubspot_tool/)
  • GitHub (tools/github_tool/)
  • Apollo (tools/apollo_tool/)
  • BigQuery (tools/bigquery_tool/)
  • Razorpay (tools/razorpay_tool/)
  • Calendar (tools/calendar_tool/)
• Security/Scanning Tools (5 tools)
  • DNS Security Scanner (tools/dns_security_scanner/)
  • SSL/TLS Scanner (tools/ssl_tls_scanner/)
  • Port Scanner (tools/port_scanner/)
  • Subdomain Enumerator (tools/subdomain_enumerator/)
  • Tech Stack Detector (tools/tech_stack_detector/)
• Runtime & Logging
  • Runtime Log Tool (tools/runtime_logs_tool/)
  • Runtime Logger with L1/L2/L3 levels (runtime/runtime_logger.py)
• Audit Trail System
  • Decision tracing beyond logs
  • Compliance reporting
  • Historical query capabilities

Memory, Storage & File System Capabilities

Memory Tools

Simple pure file-based memory management

• Short-Term Memory (STM)
  • SharedState manager for in-memory state (runtime/shared_state.py)
  • Session-based storage (storage/session_store.py)
  • State-based short-term memory layer
• Conversation Memory
  • NodeConversation tracks message history (graph/conversation.py)
  • Tool results, streaming content, metadata
  • Context building for LLM prompts
• Long-Term Memory (LTM)
  • Semantic indexing for memory retrieval
  • RLM (Retrieval-augmented Long-term Memory) implementation
  • Memory persistence beyond session
  • Content-based memory search

Durable Scratchpad

Integrate a lightweight, persistent DB for long-term memory using the filesystem-as-scratchpad pattern.

• Filesystem as Scratchpad
  • File-based persistence layer (storage/)
  • Session store implementation
  • Data durability guarantees
• Checkpoint System
  • Save/restore execution state (storage/checkpoint_store.py)
  • TTL-based cleanup
  • Async checkpoint support
  • Max age configuration
• Message Model & Session Management
  • Message class with structured content types
  • Session classes for conversation state
  • Per-message file persistence
  • Migration from monolithic run storage

Memory Isolation

Enforce session-local memory isolation to prevent data bleed between concurrent agent runs.

• Session Isolation
  • Session-local memory implementation (storage/session_store.py)
  • Data bleed prevention
  • Concurrent run safety
  • Isolation levels: ISOLATED, SHARED, SYNCHRONIZED
• State Management
  • SharedState with thread-safe operations (runtime/shared_state.py)
  • Session-scoped state access
• Context Management
  • Message.stream(sessionID) implementation
  • Full context building optimization
  • Message to model conversion improvements

Agent Capabilities

Implement File I/O support, streaming mode, and allow users to supply custom functions as libraries/nodes.

• File I/O
  • File read/write operations (mcp/agent_builder_server.py)
  • File system navigation
  • Directory listing and search
• Execution Streaming
  • Real-time event streaming (runtime/execution_stream.py)
  • Token-by-token output via event bus
  • Tool call streaming
• Custom Tool Integration
  • MCP server discovery (mcp/agent_builder_server.py)
  • Dynamic tool binding
  • Custom tool registration
• Streaming Mode Enhancements
  • Progressive result delivery optimization
  • Backpressure handling
• Custom Function Libraries
  • User-supplied function libraries as nodes
  • Library versioning and management
• Proactive Memory Compaction
  • Overflow detection
  • Backward-scanning pruning strategy
  • Token tracking integration for compaction decisions

File System Enhancements

Add semantic search capabilities and an interactive file system for frontend product integration.

• File Search
  • search_files tool (mcp/agent_builder_server.py)
  • Directory traversal
• Semantic Search
  • Semantic indexing of files
  • Natural language file search
  • Content-based retrieval with embeddings
• Interactive File System
  • Frontend file browser integration
  • Real-time file system updates
  • Visual file navigation in GUI

Eval System, DX, & Open Source Guardrails

Eval System

Build the failure recording mechanism and an SDK for defining custom failure conditions.

• Multi-Level Evaluation
  • Level 0: Output key validation (all required keys set)
  • Level 1: Literal checks (output_contains, output_equals)
  • Level 2: Conversation-aware judgment (graph/conversation_judge.py)
• Goal-Based Constraints
  • Hard constraints (violation = failure) (graph/goal.py)
  • Soft constraints (prefer not to violate)
  • Categories: time, cost, safety, scope, quality
  • Constraint checking infrastructure
• Success Criteria Definition
  • Weighted criteria (0.0-1.0)
  • Metrics: output_contains, output_equals, llm_judge, custom
  • 90% threshold for goal success
• Test Framework
  • TestCase, TestResult, TestStorage classes (testing/)
  • LLM-based judgment for semantic evaluation (testing/llm_judge.py)
  • Approval CLI for manual approval workflows
  • Categorization and test result reporting
• Failure Recording
  • Failure capture mechanism
  • Failure analysis tools
  • Historical failure tracking
  • Continuous improvement loop
• Custom Failure Conditions SDK
  • SDK for defining custom failure conditions
  • Custom evaluator framework extension
  • Condition validation DSL

Guardrails SDK

Implement deterministic condition guardrails directly in the node, complete with mitigation tracking and audit logs.

• Goal Constraints (Basic Guardrails)
  • Hard/soft constraint definitions (graph/goal.py)
  • Constraint checking in goals
• Deterministic Guardrails SDK
  • In-node guardrail implementation
  • Condition-based guardrails
  • Guardrail SDK for custom rules
• Monitoring & Tracking
  • Mitigation tracking for violations
  • Audit log system for guardrails
  • Compliance reporting
• Basic Monitoring Hooks
  • Agent node SDK monitoring hooks
  • Event hook system for guardrails
  • Default monitoring hooks in nodes

DevTools CLI

Release CLI tools specifically for rapid memory management and credential store editing.

• Main CLI
  • Run, info, validate, list commands (cli.py)
  • Dispatch mode for batch execution
  • Shell mode for interactive use
  • Model selection configuration
• Testing CLI
  • test-run, test-debug, test-list, test-stats (testing/cli.py)
  • Pytest integration
  • Test categorization
• TUI (Terminal UI)
  • Interactive chat with streaming (tui/app.py)
  • Multi-graph management UI
  • Log pane for real-time output
  • Keyboard shortcuts (Ctrl+C, Ctrl+D, etc.)
• Memory Management CLI
  • Memory inspection commands
  • Memory cleanup utilities
  • Session management commands
• Credential Store CLI
  • Interactive credential editing
  • Secure credential viewer
  • Credential validation tools
• Debugging Tools
  • Interactive debugging mode beyond TUI
  • Breakpoint support in execution
  • Step-through execution

Observability

Support user-driven log analysis, basic monitoring hooks from the SDK, and an interactive debugging mode.

• Runtime Logging
  • L1 (summary), L2 (detailed), L3 (tool) logging levels (runtime/runtime_logger.py)
  • Session logs directory storage
  • Audit trail for decision tracing in logs
• Event Bus Monitoring
  • Real-time event streaming (runtime/event_bus.py)
  • LLM text deltas, tool calls, node transitions
  • Graph-scoped event routing
• Log Analysis Tools
  • User-driven log analysis (OSS approach)
  • Log aggregation utilities
  • Log visualization tools
• Monitoring Hooks
  • Basic observability hooks from SDK
  • Performance metrics collection
  • Health checks system
• Token Tracking
  • Reasoning token tracking
  • Cache token tracking
  • Token metrics in compaction logic

Developer Success

Write the Quick Start guide, detailed tool usage documentation, and set up the MVP README examples.

• Documentation
  • Quick start guide
  • Goal creation guide
  • Agent creation guide
  • README with examples
  • Contributing guidelines
  • GitHub Page setup
• Tool Usage Documentation
  • Comprehensive tool documentation
  • Tool integration examples
  • Best practices guide
• Video Content
  • Introduction video
  • Tutorial videos
• Example Agents
  • Knowledge agent template
  • Blog writer agent template
  • SDR agent template

Deployment, CI/CD & Community Templates

Self-Deployment

Standardize the Docker container builds and establish headless backend execution APIs.

• Docker Support
  • Python 3.11-slim base image (tools/Dockerfile)
  • Playwright Chromium installation
  • Non-root user for security
  • Health check endpoint
  • Volume mount for workspace persistence
  • Exposes port 4001 for MCP server
• Agent Runtime
  • AgentRuntime: Top-level orchestrator (runtime/agent_runtime.py)
  • Multiple entry points (manual, webhook, timer, event, api)
  • Concurrent execution management
  • State persistence via session store
  • Outcome aggregation
• Async Entry Points
  • AsyncEntryPointSpec: Webhook, timer, event triggers (graph/edge.py)
  • Timer config: cron expressions or interval_minutes
  • Event triggers for custom events
  • Isolation levels: isolated, shared, synchronized
• Headless Backend Enhancements
  • Standardized backend execution APIs
  • Frontend attachment interface
  • Self-hosted setup guide with examples

Lifecycle APIs

Expose basic REST/WebSocket endpoints for external control (Start, Stop, Pause, Resume).

• Webhook Server
  • FastAPI-based webhook server (runtime/webhook_server.py)
  • Route configuration per entry point
  • Optional secret validation
• Graph Lifecycle Management
  • Load/unload/start/restart in AgentRuntime
  • State persistence
  • Recovery mechanisms
• REST API Endpoints
  • Start endpoint for agent execution
  • Stop endpoint for graceful shutdown
  • Pause endpoint for execution suspension
  • Resume endpoint for continuation
  • Status query endpoint for monitoring
• WebSocket API
  • Real-time event streaming to clients
  • Bidirectional communication
  • Connection management with reconnection

CI/CD Pipelines

Implement automated test execution, agent version control, and mandatory test-passing for deployment.

• Test Execution
  • Test framework with pytest integration (testing/)
  • Test result reporting
  • Test CLI commands (test-run, test-debug, etc.)
• Automated Testing Pipeline
  • CI integration (GitHub Actions, etc.)
  • Mandatory test-passing gates
  • Coverage reporting
• Version Control
  • Agent versioning system
  • Semantic versioning for agents
  • Version compatibility checks
• Deployment Automation
  • Continuous deployment pipeline
  • Rollback mechanisms
  • Blue-green deployment support

Distribution

Launch the official PyPI package, Docker Hub image, and the community Discord channel.

• Package Distribution
  • Official PyPI package
  • Docker Hub image publication
  • Version release automation
  • Installation documentation
• Community Channels
  • Discord channel setup
  • Community support structure
  • Contribution guidelines enforcement
• Cloud Deployment
  • AWS Lambda integration
  • GCP Cloud Functions support
  • Azure Functions support
  • 3rd-party platform integrations
  • Self-deploy with orchestrator connection

Example Agents

Ship ~20 ready-to-use templates including GTM Sales, Marketing, Analytics, Training, and Smart Entry agents.

• Hive Coder Agent
  • Agent builder template (agents/hive_coder/)
  • Guardian node for supervision
• Sales & Marketing Agents
  • GTM Sales Agent (workflow automation)
  • GTM Marketing Agent (campaign management)
  • Lead generation agent
  • Email campaign agent
  • Social media agent
• Analytics & Insights Agents
  • Analytics Agent (data analysis)
  • Data processing agent
  • Report generation agent
  • Dashboard agent
• Training & Education Agents
  • Training Agent (onboarding)
  • Content creation agent
  • Knowledge base agent
  • Documentation agent
• Automation & Forms Agents
  • Smart Entry / Form Agent (self-evolution emphasis)
  • Data validation agent
  • Workflow automation agent
  • Integration agent
• Additional Templates
  • Customer support agent
  • Document processing agent
  • Scheduling agent
  • Research agent
  • Code review agent

Open Hive

Local API Gateway

Build a lightweight local server (e.g., FastAPI or Node) that securely exposes the Hive framework's core Event Bus and Memory Layer to the local browser environment.

• MCP Server Foundation
  • FastMCP server implementation (mcp/agent_builder_server.py)
  • Agent builder tools exposed
  • Port 4001 exposed in Docker
• Event Bus Architecture
  • Event Bus implementation (runtime/event_bus.py)
  • Real-time event streaming
  • Graph-scoped event routing
• Local API Gateway
  • Lightweight local server (FastAPI or Node)
  • Secure authentication layer for browser
  • CORS and security configuration
  • Event Bus API endpoints for browser access
  • Event subscription management for frontend
• Memory Layer API
  • Memory read/write endpoints
  • Session management API for frontend
  • Memory visualization data endpoints

Visual Graph Explorer

Implement an interactive, drag-and-drop canvas (using libraries like React Flow) to visualize the Worker Graph, Queen Bee, and active execution paths in real-time.

• Graph Visualization
  • React Flow integration
  • Worker Graph rendering from agent definitions
  • Node type visualization (EventLoop, Function, etc.)
  • Edge visualization with condition types
  • Active execution path highlighting
• Interactive Features
  • Drag-and-drop canvas for graph editing
  • Node editing capabilities
  • Real-time graph updates during execution
  • Zoom and pan controls
  • Node inspection on click
• Integration with Runtime
  • Live execution visualization
  • Node state indicators
  • Edge traversal animation

TUI to GUI Upgrade

Port the existing Terminal User Interface (TUI) into a rich web application, allowing users to interact directly with the Queen Bee / Coding Agent via a browser chat interface.

• TUI Foundation
  • Terminal chat interface (tui/app.py)
  • Streaming support
  • Multi-graph management
  • Log pane display
  • Keyboard shortcuts
• Web Application
  • Modern web UI framework setup (React/Vue/Svelte)
  • Responsive design implementation
  • Cross-browser compatibility
• Chat Interface
  • Browser-based chat UI
  • Hive Coder interaction (Queen Bee proxy)
  • Coding Agent interface
  • Message history and search
  • Rich message formatting (markdown, code blocks)
• TUI Feature Parity
  • All TUI commands in GUI
  • Keyboard shortcuts in browser
  • Command palette (Cmd+K style)

Memory & State Inspector

Create a UI component to inspect the Shared Memory and Write-Through Conversation Memory, allowing developers to click on any node and see exactly what it is thinking.

• Runtime Logs Tool
  • Inspect agent session logs (tools/runtime_logs_tool/)
  • Session state retrieval (mcp/agent_builder_server.py)
• Memory Inspector UI
  • Shared Memory visualization
  • Conversation memory view (NodeConversation display)
  • Memory search and filter
  • Memory timeline view
• Node State Inspection
  • Click-to-inspect functionality
  • Node thought process display (LLM reasoning)
  • State history timeline per node
  • Input/output inspection
• Debug Tools
  • Memory diff viewer (state changes between nodes)
  • State snapshot comparison
  • Memory leak detection

Local Control Panel

Build a dashboard for localized Credential Management (editing the ~/.hive/credentials store safely) and swarm lifecycle management (Start, Pause, Kill, and HITL approvals).

• Credential Management Backend
  • CredentialStore with file/env/vault backends (credentials/store.py)
  • OAuth2 provider support (credentials/oauth2/)
  • Template resolution and caching
• Credential Management Dashboard
  • Safe credential editing interface (web UI)
  • ~/.hive/credentials store management UI
  • Credential validation and testing UI
  • Encryption status display
  • OAuth2 flow initiation from browser
• Swarm Lifecycle Management
  • Start/Stop controls for agents
  • Pause/Resume functionality
  • Kill process management
  • HITL approval interface in browser
  • Multi-agent orchestration view
• Monitoring Dashboard
  • Active agents display
  • Resource usage monitoring (CPU, memory, tokens)
  • Performance metrics visualization
  • Execution history

Local Model Integration

Build native frontend configurations to easily connect Open Hive's backend to local open-source inference engines like Ollama, keeping the entire stack offline and private.

• LLM Integration Layer
  • Provider-agnostic LLM support via LiteLLM (graph/event_loop_node.py)
  • Model configuration in agent definitions
• Local Model Support
  • Ollama integration and configuration
  • Local LLM configuration UI
  • Model selection and management dashboard
  • Model performance monitoring
• Offline Mode
  • Full offline functionality (no cloud API calls)
  • Local-only execution mode flag
  • Privacy-first architecture enforcement
  • Local model fallback mechanisms
• Model Configuration
  • Easy model switching in UI
  • Model parameter tuning (temperature, top_p, etc.)
  • Performance optimization settings
  • Multi-model support (different models per node)
  • Model cost tracking for local models

Cross-Platform Support

• JavaScript/TypeScript SDK
  • TypeScript SDK development
  • npm package distribution
  • Node.js runtime support
  • Browser runtime support
• Platform Compatibility
  • Windows support improvements
  • macOS optimization
  • Linux distribution support

Coding Agent Integration

• IDE Integrations
  • Claude Code integration
  • Cursor integration
  • Opencode integration
  • Antigravity integration
  • Codex CLI integration (in progress)