AgentHub

AgentHub is a self-hosted agent loop toolchain. Agents use IM, task lists, execution tools, and Nowledge Mem to advance work, with one configured role prompt per activation. Leader and worker roles share the same loop mechanism; Agent Cards configure participants, and processes may exit after a loop finishes.

This is the target product direction. Durable activation of offline agents and the complete Mem integration are pending implementation. See the product model and runtime design for contracts and migration boundaries. The installation and operational capabilities below describe the existing runtime.

Quick links: Docs Site · Install AgentHub · Why AgentHub · Remote Agent Nodes · Documentation · Developer Docs

Work can outlive a provider session or process. AgentHub's loop model keeps task ownership, messages, outcomes, and knowledge available for the next activation. Agents decide how to advance the task; the runtime supplies tools, scheduling, isolation, and inspectable execution history.

The intended flow is: express a goal in IM, let agents maintain the task list, review progress and evidence, and provide decisions when needed. Waiting agents can record what will wake them next and exit.

• Create, start, stop, reconnect, and delete agents
• View ACP events such as messages, plans, tool calls, command output, and debug streams
• Run multi-agent Team workflows with coordinator/worker coordination
• Install AgentHub as an app-like PWA shell while still picking up fresh web deploys on refresh
• Register remote execution nodes and start agents on those nodes
• Persist session history and operational records in SQLite
• Receive completion notifications in the web UI

Official release binaries are available for:

• macOS Apple Silicon (darwin-arm64)
• Linux x86_64
• Linux aarch64

Windows and macOS Intel binaries are not currently published.

Recommended installation paths:

• Ubuntu/Debian: install the matching .deb from the latest release. It includes agenthub, agenthubd, and a systemd service.
• macOS or portable Linux: install the matching agenthub and agenthubd archives from the same release and verify them with SHA256SUMS.txt.
• npm: npm install -g @linkerdog/agenthub installs both AgentHub executables through the matching platform package.

Codex-backed agents additionally require the official Codex CLI version 0.150.1. Install it separately and ensure the daemon can execute it as codex, or configure an absolute path with [codex_acp].runtime_binary.

The Homebrew tap currently trails the primary release channel and installs a legacy ACP helper. Use release archives for a new complete installation until the formula is brought back into version and adapter parity.

After installing the complete runtime:

agenthub --version
agenthubd --version
codex --version
agenthub init
agenthubd

Then open http://localhost:8080. For package-specific commands, checksum verification, upgrades, uninstall behavior, platform limitations, and the current Linux runtime caveat, see Installation and Startup.

For local source development, contributor setup, repository layout, and common commands, see docs/developer-setup.md.

The target design separates durable work from temporary execution:

The existing implementation supplies these foundations:

• a single Rust backend
• an embedded React web UI
• ACP-based structured output rendering
• SQLite-backed persistence
• Team coordinator/worker orchestration
• optional remote execution over internal gRPC

The main design goal is simple: keep AI agents observable, controllable, and recoverable even when the browser closes, the task lasts for hours, or the work must be split across multiple agents and machines.

AgentHub is built for engineering teams that want a practical AI agent workspace instead of a disposable chat box.

• ⏳ Browser-independent execution
  • Keep work observable across browser refreshes and disconnects
• 🧾 Structured ACP timelines
  • Inspect plans, tool calls, command output, and replayable history
• 👥 Team workflows
  • Coordinate coordinator/worker execution with channels, Kanban, and ACP views
• 🌐 Remote agent nodes
  • Run agents on other machines while keeping one main control plane
• 💾 Persistent runtime state
  • Store session history, operational state, and audit records in SQLite

In one product surface, you can:

• create, start, stop, reconnect, and delete agents
• keep sessions alive after the browser tab closes
• restart or recover stuck sessions without losing the operational surface
• review structured agent output and replayable history
• inspect per-agent execution details when runtime debugging is needed
• run multi-agent Team workflows in a shared workspace
• route execution to remote nodes when one machine is not enough

AgentHub includes a Team workbench for coordinator/worker coordination.

Core concepts:

• Channels for shared coordination
• # all as the default Team lane
• Kanban as the canonical Team task surface
• per-member ACP inspection when deep runtime debugging is needed

• 👥 Multi-agent collaboration
  • Organize multiple AI agents in one Team instead of one isolated session.
• 🧩 Shared workspace
  • Keep people and agents in one workspace with shared context and progress.
• 💬 Channel-based communication
  • Talk to the whole Team in shared channels instead of scattered side sessions.
• 🧵 Threaded follow-up
  • Reply in thread for a specific question or update without derailing the main channel.
• 📋 Task coordination
  • Manage planning, ownership, and status transitions in a dedicated task surface.
• 👀 Visible progress
  • See what each agent is doing, what changed, and where work is blocked.
• 🔍 Per-agent inspection
  • Open one member and inspect its ACP timeline and execution details directly.
• ⏱️ Built for long-running work
  • Let Team work continue beyond one browser session or one short interactive turn.
• 🛠️ Role-based division of work
  • Split planning, implementation, review, and verification across different agents.
• 🎛️ Unified control surface
  • Start, stop, inspect, and steer the whole Team from one product interface.
• 🌐 Remote execution ready
  • Run Team members on different machines while keeping one shared control plane.

If you want remote execution, run the same agenthub release on every machine. Keep the main process in its default main role, enable internal gRPC on both sides, and configure each remote process with role = "node" plus a unique node_id.

[server]
role = "node"
node_id = "node-east"

[internal_grpc]
enabled = true
listen = "0.0.0.0:50051"

[internal_grpc.auth]
shared_secret = "<shared-secret-from-your-secret-store>"
issuer = "agenthub"
audience = "agenthub-internal"

[internal_grpc.bootstrap]
token = "<node-bootstrap-token>"

Use TLS or mTLS on a private network, then register the reachable gRPC target from the root-only node controls on the Agents page. See the Agent Nodes user guide for onboarding and the current transport boundary.

• Docs site: doc.agenthub.hawkingrei.com
• Product overview: Product Overview
• Feature overview: Feature Overview
• Installation: Installation and Startup
• Team workbench guide: Team Workbench
• Agent nodes: Agent Nodes and Remote Execution

• Developer docs index: docs/README.md
• Developer setup: docs/developer-setup.md
• Architecture map: docs/architecture-map.md
• Active engineering backlog: docs/todo.md
• Project charter and constraints: AGENTS.md

AgentHub is a strong fit for:

• engineers advancing coding tasks across agent sessions
• teams experimenting with coordinator/worker multi-agent workflows
• operators who need structured runtime visibility
• organizations that want self-hosted agent control instead of opaque hosted sessions
• users who need one control plane across local and remote execution targets

Source development workflow, repository layout, common commands, and CI expectations live in docs/developer-setup.md.

Apache-2.0