Most teams already have docs, task boards, repos, chats, meetings, and local coding agents. The hard part is not creating another chat box. The hard part is making agents understand the same context, follow the same process, use the right tools, ask for review at the right moment, and continue work without a human synchronously driving every step.

Multigent is built around that operating model:

• Shared agent context: workspace, team, role, project, task, docs, skills, tools, and workflow state are managed in one place.
• Humans and agents in one project: people and agents share the same project space, task queue, workflow steps, reviews, and handoff records instead of working in separate tools.
• RBAC for mixed teams: workspace roles, project membership, agent permissions, tool access, and review gates define what every human or agent can see and do.
• Agent-ready task execution: tasks can bind to workflows, carry structured inputs and outputs, and move between agents and humans.
• Human review without human blocking: humans act as owners, reviewers, and process designers instead of being the mandatory runtime loop.
• External tools as capabilities: GitHub, Feishu/Lark, Slack, Linear-style project systems, web search, design tools, and other services are modeled as workspace tools that agents can use through controlled runtime adapters.
• Observable agent work: runs, chat sessions, workflow steps, task history, tokens, logs, and audit events are visible from the web console.
• Sandbox-first execution: agents run in isolated environments with explicit credentials and tool access instead of reading the whole workspace by default.

• Multi-agent autonomous wakeups: agents can be woken by tasks, heartbeat schedules, cron jobs, manual triggers, and collaboration events, so work can keep moving without a human constantly copying prompts around.
• Loop engineering for human-agent collaboration: prompts, skills, tools, model accounts, schedules, and review policies are managed as a repeatable operating loop rather than one-off conversations.
• Visual SOP and workflow orchestration: design task flows on a board, define required inputs and outputs, add review loops and branch conditions, then bind real tasks to that workflow.
• Role-based control for humans and agents: assign people and agents to the same project, then control project access, task visibility, tool credentials, workflow actions, and audit trails through scoped permissions.
• Human-in-the-loop by design: humans can review, approve, reject, or redirect at key workflow steps while agents continue handling the repeatable work around them.
• Demo video coming next: a short product walkthrough will be added as the public demo workspace stabilizes.

Workspace
  -> Teams and roles
  -> Projects
  -> Agents and humans
  -> Tasks
  -> Workflows
  -> Docs, skills, model accounts, and external tools

Multigent does not try to replace every existing system on day one. A company can keep using Jira, Linear, Plane, Huly, GitHub, Feishu/Lark, Slack, local agent CLIs, and internal docs. Multigent provides the agent-native coordination layer across those systems.

Create agent collaborators with a role, model account, CLI runtime, sandbox, skills, and external tool access. Humans and agents work in the same project through web chat, scheduled wakeups, tasks, reviews, and workflow steps.

Agents are not limited to synchronous chat. They can run task-triggered wakeups, heartbeat routines, cron jobs, and manual wakeups. Teams can tune the loop around each agent: what context it receives, what tools it can use, when it should ask for review, and how it reports output.

Design reusable workspace-level workflows on a visual board. A workflow defines steps, actors, required inputs, required outputs, review loops, branch conditions, and handoffs. Tasks can then choose a workflow and assign each actor to a human or an agent.

Install opinionated collaboration packages that bundle teams, roles, skills, and workflows. Playbooks help new workspaces start with a proven process instead of an empty canvas.

Configure tools once at the workspace level and expose them to selected agents. Multigent is designed to support multiple access patterns: platform CLIs, MCP gateways, API keys, OAuth apps, and runtime materialization.

Store and reference documents by doc ID. Agents can create and read docs through the runtime CLI so workflow outputs can point to durable knowledge instead of ephemeral chat text.

Use task-triggered wakeups, heartbeat schedules, cron jobs, and manual wakeups. Run records capture status, runtime session IDs, token usage where available, logs, and workflow step outputs.

Workspace roles, project membership, task visibility, user invitations, agent permissions, tool access, review gates, and audit events are first-class concepts. Humans and agents are treated as principals in the same collaboration system, with scoped permissions that decide what they can read, change, run, approve, or hand off.

The easiest way to try Multigent is to ask your coding agent to install and start it for you. Multigent ships an agent-readable setup guide:

Read https://github.com/multigent/multigent/blob/main/INSTALL.md
Install Multigent on this machine, start the web console, and tell me the local URL.
Before creating teams, agents, workflows, or credentials, explain the plan and ask me to confirm.

This works well with Claude Code, Codex, Cursor, and similar local agent environments. The agent can choose the right install path, verify Docker, start the server, and help you configure the first workspace.

After installation, run the built-in beginner demo first:

Run the Hello World Relay

Shortest path:

1. Enter Example Workspace.
2. Add one usable model account in Settings -> Model Accounts.
3. Bind that model account to the three demo agents in Projects -> hello-world-relay -> Members.
4. Run multigent sandbox prepare.
5. Open Projects -> hello-world-relay -> Schedule and manually wake the current owner.
6. When the workflow reaches human review, approve or send it back from Workbench -> Tasks.

macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/multigent/multigent/main/scripts/install.sh | bash
multigent version
mga version

Homebrew:

brew install multigent/tap/multigent

Windows PowerShell:

irm https://raw.githubusercontent.com/multigent/multigent/main/scripts/install.ps1 | iex

npm wrapper:

npm install -g @multigent/multigent

Docker self-host:

docker run --rm -p 27892:27892 \
  -v multigent-data:/data \
  -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/multigent/multigent:latest

Open http://127.0.0.1:27892.

Default initial login:

Username: admin
Password: admin123

Change the password immediately after first login.

• Docker, for sandboxed agent execution

Multigent publishes the default multi-architecture runtime image at ghcr.io/multigent/multigent/runtime-base:latest. The image provides stable sandbox dependencies and a fallback Linux mga; normal runs synchronize the mga version that matches the Multigent server into the persistent Docker toolchain volume. Native macOS and Windows binaries are never mounted into Linux sandboxes. The published GHCR package is public and does not require docker login.

Recommended first-run preparation:

multigent sandbox prepare

For mainland China installs, use the Alibaba Cloud mirror:

multigent sandbox prepare --region cn

This pulls the runtime image and warms common agent CLI toolchains before the first chat, so users do not confuse a long Docker pull with an agent failure. The image is intentionally kept as a stable runtime base; fast-moving agent CLIs are installed into the persistent toolchain cache, and heavier project-specific compilers belong in custom runtime images or templates.

The production-style command serves the API and embedded frontend from one binary:

multigent --dir ./data start --addr 127.0.0.1:27892 --open

For frontend development with Vite hot reload:

make build
./dist/multigent --dir ./data api serve --addr 127.0.0.1:27893
cd web
npm install
npm run dev

Open the Vite URL shown in the terminal, usually http://127.0.0.1:27894.

1. Register the first user.
2. Create a workspace.
3. Invite members or continue alone.
4. Create or install teams, roles, and playbooks.
5. Add a project.
6. Add agents to the project.
7. Configure model accounts and external tools.
8. Create a workflow or use a built-in workflow.
9. Create a task and bind it to the workflow.
10. Watch the task move between agents and humans, with structured outputs recorded at every step.

┌─────────────────────────┐
│      Web Console        │
│  React + workflow UI    │
└───────────┬─────────────┘
            │ HTTP / SSE
┌───────────▼─────────────┐
│      Go API Server      │
│ auth, RBAC, tasks, docs │
│ workflows, tools, runs  │
└───────────┬─────────────┘
            │
┌───────────▼─────────────┐
│      Storage Layer      │
│ SQLite today, interface │
│ ready for other DBs     │
└───────────┬─────────────┘
            │
┌───────────▼─────────────┐
│   Runtime Materializer  │
│ sandbox, CLI, skills,   │
│ credentials, tools      │
└───────────┬─────────────┘
            │
┌───────────▼─────────────┐
│  Isolated Agent Runtime │
│ Codex, Claude Code,     │
│ Cursor, tool CLIs, MCP  │
└─────────────────────────┘

For deeper design notes, see the further reading section below.

• Documentation index
• Agent runtime CLI architecture
• Workflow state machine
• Configuration and logging
• Release and distribution

Join the community to discuss agent workflows, multi-agent operations, product feedback, and real-world deployment:

• Telegram: https://t.me/+kjUY8qQekRwyYjY1
• Discord: https://discord.gg/wqweEt62sp
• WeChat: scan the QR code below, add the personal account, and mention multigent to be invited into the group.

make test
make web
make build-go

Useful commands:

# Start API only
./dist/multigent --dir ./data api serve --addr 127.0.0.1:27893

# Start API + embedded web
./dist/multigent --dir ./data start --addr 127.0.0.1:27892

# Inspect worker/runtime configuration
./dist/multigent worker inspect

Configuration can be supplied through CLI flags, environment variables, or a TOML file. See configuration and logging.

Multigent is under active product development. The repository already includes the web console, workspace model, users and invitations, teams and roles, agents, model accounts, external tools, tasks, workflow definitions, scheduler, sandbox runtime abstraction, docs, playbooks, and telemetry.

The near-term focus is making the end-to-end journey production-grade:

• smoother onboarding and example workspaces;
• stronger sandbox isolation and runtime materialization;
• richer workflow execution and visual observability;
• better external tool adapters;
• cleaner product packaging for self-hosted and commercial deployments.

Multigent is source-available under the PolyForm Noncommercial License 1.0.0.

Commercial use is not permitted without a separate written commercial license from the copyright holder.