AgentHub

AgentHub is a self-hosted AI agent control plane for long-lived coding agents, structured ACP timelines, multi-agent Team workflows, and optional remote execution nodes.

It is designed for teams that want one product surface for long-running coding agents, structured ACP review, shared Team coordination, and remote execution without introducing a separate control plane.

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

Most agent tools are optimized for a single terminal session. AgentHub is built for the operational side of agent workflows.

It keeps long-running agents, structured ACP review, Team coordination, remote agent nodes, and persistent runtime state in one product surface instead of splitting them across disposable chats, terminal tabs, and ad hoc scripts.

In practice, AgentHub sits closer to an AI agent control plane or shared workbench than to a thin prompt UI.

• 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, agenthub-acp, and a systemd service.
• macOS or portable Linux: install the matching agenthub and agenthub-acp archives from the same release and verify them with SHA256SUMS.txt.
• npm: npm install -g @linkerdog/agenthub installs only the agenthub control-plane binary; install the matching agenthub-acp release archive separately before running the default Codex or Claude adapters.

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 both binaries:

agenthub --version
agenthub-acp --version
agenthub init
agenthub

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.

AgentHub is a Rust-based control plane for operating AI agents beyond one ephemeral terminal tab.

It combines:

• 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.

• ⏳ Long-lived agent control
  • Keep coding agents alive 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 running long-lived coding agents
• 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