AgentHub Documentation

AgentHub turns AI agents into teammates you can chat with. Instead of staring at terminal logs alone, you give agents tasks in a group chat, watch them work, and review what they change — like having a colleague in Feishu or WeChat who writes code, researches problems, and polishes docs.

You can run agents locally from a desktop app, collaborate with your team in a browser, or check progress on your phone. All three clients share the same workbench, so the interface stays familiar wherever you are.

Start Here

If you’re new to AgentHub, pick your path first:

Reader	Read first	You’ll learn
Product evaluator	Product Status -> Comparison -> Roadmap	What’s available today, and how AgentHub differs from CLI tools as an IM-form collaboration platform
Local user	Installation -> Desktop Guide -> Quickstart	Run the full Desktop -> Local Edge -> execution engine path on your own machine
Runtime integrator	Agent Profiles -> Run Lifecycle -> Adapters -> API And Events	How to map your execution engine into AgentHub’s messaging, approval, and diff review model
Team/workflow owner	Collaboration -> Hub And Edge -> Web Workbench -> Feishu/Lark Integration	How to manage agent tasks in group chats, conduct reviews as a team, and receive IM notifications
Release owner	Security -> Operations Runbook -> Deployment -> Release Checklist	What to verify before release: docs, visuals, SEO, and launch messaging

Full recommended reading order:

1. Concepts: understand Desktop, Web, Hub, Edge, Agent Profile, Runtime adapter, Run, and Event.
2. Product Status: separate live, preview-ready, contract-shaped, in-progress, and in-development capabilities.
3. Quickstart: start the smallest local flow and verify Desktop, Local Edge, and a runtime adapter can work together.
4. Installation: prepare a workstation with Git, Go, Node.js, pnpm, Local Edge, Desktop, and a safe runtime path.
5. Glossary: align product, runtime, identity, integration, and release terms.
6. Workflows: map local runs, reviewable diffs, team collaboration, Feishu/Lark tasks, adapters, and releases to concrete evidence.
7. Usage Cookbook: follow concrete recipes for read-only reviews, reviewable diffs, adapter comparison, failed-run triage, team task prep, Feishu/Lark prep, and docs releases.
8. Desktop Guide: understand the local workbench, runtime selector, diff review, approvals, and QA evidence.
9. Desktop UI Reference: review layout, run states, selectors, diff panels, motion, and screenshot QA.
10. Configuration: review local, Hub/Web, runtime profile, and secret ownership before wiring real credentials.
11. Identity And Login: confirm TokenDance ID login, callback, browser state, and authorization boundaries.
12. Architecture: learn the Hub / Edge / Desktop / Web responsibility boundaries.
13. Hub And Edge: check the collaboration/execution split, routing, event contract, and integration entry boundary.
14. Web Workbench: understand Hub-backed Web surfaces, local-file boundaries, review flow, and evidence.
15. Agent Profiles: define profile metadata, capabilities, approval policy, and adapter boundaries.
16. Collaboration: map shared sessions, team roles, approvals, integration entries, and evidence.
17. Run Lifecycle: follow run states, event envelopes, approval gates, artifacts, diffs, and failure codes.
18. API And Events: review the public REST, WebSocket event, and runtime adapter contract boundaries.
19. FAQ: answer common product, setup, identity, runtime, integration, and release questions.
20. Design System: follow TokenDance Blue, Desktop mock, icon, motion, and visual QA rules.
21. Deployment: use the static-export, smoke, and stale-page triage guide.

Documentation Map

Area	What it covers	Status
Concepts	Terms, product surfaces, delivery status, and boundaries	Living document
Product Status	Live, preview-ready, contract-shaped, in-progress, and in-development capability map	Living document
Glossary	Product, runtime, identity, integration, and release terminology	Living document
Workflows	Local runs, diff review, collaboration, Feishu/Lark, adapter, and release workflows	Living document
Usage Cookbook	Practical recipes for read-only reviews, diff review, adapter comparison, failed-run triage, team tasks, Feishu/Lark prep, and docs releases	Living document
Installation	Workstation setup, runtime CLI preparation, local ports, verification, and first failure triage	Living document
Desktop Guide	Desktop surface map, runtime controls, diff review, approvals, theme/language evidence	Living document
Desktop UI Reference	Layout model, run states, selectors, runtime picker, diff panels, motion, and screenshot QA	Living document
Quickstart	Local preview, configuration, and first agent task	Preview-ready
Configuration	Local Edge, Hub/Web, runtime profile, and secret ownership	Living document
Identity And Login	TokenDance ID login flow, callback, browser state, authorization boundary, and UI rules	Living document
Architecture	Hub, Edge, Desktop, Web, runtime adapters, and event flow	Preview-ready
Hub And Edge	Hub/Edge responsibility split, routing, event contract, and integration entries	Living document
Web Workbench	Hub-backed Web surfaces, local-file boundary, review flow, UI states, and evidence	In progress
Agent Profiles	Profile model, capability vocabulary, selection rules, approval policy, and adapter boundary	Contract shaped
Collaboration	Shared sessions, review/approval flow, team roles, integration entries, and evidence	In progress
Run Lifecycle	Run state machine, event envelope, approval gates, artifacts, diff metadata, and failure codes	Contract shaped
Adapters	Claude Code, Codex, OpenCode, and custom adapter contracts	Contract shaped, public SDK not stable
API And Events	Hub API, Edge API, WebSocket events, adapter events	In development
Feishu/Lark Integration	Bot, events, cards, H5/workbench, TokenDance ID binding	In development
Security	TokenDance ID, Hub-local permissions, secrets, sandbox, and audit	Living document
Operations Runbook	Public-site checks, docs route release gate, visual QA, smoke, and failure triage	Living document
Deployment	Release source, local build, static export, live smoke, and stale-page triage	Living document
Troubleshooting	Setup, login, runtime, Feishu, and static-site failures	Living document
FAQ	Product, setup, identity, runtime, integration, docs, and release questions	Living document
Release Checklist	Docs, SEO, visual QA, security, and deployment gates	Living document
Roadmap	Capability status and conservative release language	Living document
Design System	TokenDance Blue, component rules, Desktop mock, motion, icon, and visual QA guidance	Living document
Comparison	Positioning against CLIs, chat UIs, and single-agent tools	Living document
Changelog	Public docs and product-site changes	Living document

What AgentHub Is

Most AI coding tools start as a private terminal session: you type commands, watch logs scroll by, and declare the result good enough. One person, one screen, one verdict.

AgentHub moves that into a group chat. Add AI agents to a channel, send messages as tasks, and your chat becomes the workbench. Your team can see what the agent did, review its changes, and approve critical actions — all without leaving the conversation.

The product runs across three surfaces:

• AgentHub Desktop (Tauri 2 native app): Your local workbench. Connect to Local Edge, run agent tasks, and review results in the shared workbench UI. Built for solo work and local execution.
• AgentHub Web (browser app): Team collaboration hub. Shares the same workbench UI as Desktop. Team members review agent output and browse history from a browser, without installing anything.
• AgentHub Mobile (iOS / Android app): On-the-go chat workbench for reviewing and creating tasks from your phone.
• Hub Server: The core service that manages accounts, projects, messages, team coordination, and audit records.
• Edge Server: The execution-layer service that manages workspaces, task lifecycle, execution engine registration, and output (diffs, files, previews).
• Runtime adapters: Adapters that connect real AI engines — Claude Code, Codex, OpenCode — into AgentHub’s workflow.

AgentHub is a controlled workbench that makes agent work transparent. Who asked for the task, which engine executed it, what changed, what was approved, and what was produced — all visible to your team in a familiar chat interface.

What You Can Do Today

Preview-ready and locally verifiable:

• Desktop connects to Local Edge, driving Claude Code, Codex, or OpenCode to execute tasks. You see agent messages, changed files, and output artifacts in the workbench.
• Web runs as a team collaboration surface, sharing the same workbench as Desktop, so team members can review agent work from a browser.
• Edge Server has execution engine registration, task lifecycle management, and local execution boundaries in place.
• Hub Server has local development paths for identity, team coordination, and message routing.

In progress or still in development:

• Mobile client: iOS/Android chat workbench scaffolding is built; local workspace and runtime control are not yet wired in.
• Feishu/Lark production integration: event ingress, card callbacks, and account binding are under development.
• Remote / Cloud Edge: device identity, routing, and provisioning for remote execution nodes are not yet complete.
• Database-backed surfaces: Contacts, Docs, Tasks, Projects, and Settings.
• Production-grade end-to-end verification of the full Web + Hub + Edge path.
• Public third-party Adapter SDK and ecosystem submission flow.

When a page says “preview” or “in development,” that reflects the actual capability status.

Identity

TokenDance ID is the identity authority for AgentHub. Hub Server handles authentication via OIDC PKCE. AgentHub product permissions are issued and managed by Hub Server.

Next Step

Continue to Concepts, map your scenario in Workflows, then run the local path from Quickstart.

Edit this page on GitHub