[ open-source · mit · runs local ]

Many assistants.
One hive mind.

droid-agent is Unify's AI teammates, open-sourced. Many assistants share one typed state — a hive mind you host yourself — with real-time voice, steerable nested execution, and code-first planning.

Get it on GitHub → Quick install

Shared state is opt-in per manager — contacts, tasks, transcripts, knowledge. Typed state managers

droid://team

$ analyst.act("summarize Q3 launch risks")
$ ops.act("review rollout checklist")
$ comms.act("draft stakeholder update")

◎ shared_state
 ├─ contacts      Sarah, Finance, Launch Team
 ├─ tasks         budget_followup, q3_update
 ├─ transcripts   launch_sync, finance_thread
 └─ knowledge     rollout_notes, Q3_risks

> user: "have ops take the budget issue"
◎ shared_state.tasks.update("q3_update", "budget")
◎ ops sees the change immediately

handoff share interject inspect stop

01 Hive mind, opt-in.

02 Sub-second voice.

03 Steerable mid-run.

04 One identity across channels.

In context

droid-agent has been the agent runtime behind Unify's production AI teammates since mid-2025. It sits alongside OpenClaw and Hermes-Agent — two projects that made self-hosted AI agents real — and extends the category for teams of assistants.

OpenClaw

Personal AI assistant

Multi-channel presence
Self-hosted on your hardware
Skill-extensible
Long-running background work

Hermes-Agent

An agent that grows with you

Continual learning
Auto-generated skills
Natural-language scheduling
Delegated subagents

droid-agent

Many assistants, one hive mind

Hive mind, opt-in
Real-time voice, dual-brain
Steerable nested execution
Code-first planning

OpenClaw proved the self-hosted personal assistant. Hermes-Agent proved the self-improving agent. droid-agent extends the model to coordinated teams of assistants.

Features

Hive mind, opt-in

Typed state managers can share state across assistants — contacts, tasks, transcripts, knowledge. Opt-in per manager, scoped by workspace, auditable at the boundary.

share: contacts + tasks · scoped

Real-time voice, dual-brain

A fast voice process handles the conversation sub-second over LiveKit. A slower orchestration brain plans tool work in parallel. They coordinate over IPC using SPEAK, NOTIFY, and BLOCK messages.

slow ⇄ fast · ipc · livekit

Steerable nested execution

Every operation returns a live handle — at every level of nesting. Ask for status, interject, pause a branch, or stop one task without affecting the others. Works inside a running tool call, not just at the top.

handle.interject("also check trains")

Code plans over typed primitives

CodeActActor writes Python over typed primitives.* in a sandboxed session. One program per turn, with variables, loops, and composition.

for c in primitives.contacts.ask(...)

One identity across channels

SMS, email, phone calls, meetings, Slack, WhatsApp. One identity, one memory, one task queue across every channel.

voice · sms · email · slack · meet

Functions, typed and linked

Every 50 messages, a background pass distills contacts, tasks, preferences, and policies into typed tables. Reusable Python functions are stored alongside — validated at storage, with AST-tracked dependencies, invokable by name. Guidance procedures describe when to use each one, linked many-to-many.

typed · ast-analyzed · semantically indexed

Install

One command. Clones the code, installs Python + Docker deps, spins up a local Orchestra (Postgres + FastAPI) as the persistence backend, and wires your .env. macOS, Linux, and WSL2. No Unify account required.

# one-liner: pulls prebuilt images and runs the whole local stack
curl -fsSL https://raw.githubusercontent.com/unifyai/droid/staging/scripts/install.sh | bash

# the installer prompts for an LLM key; to add or change one later:
$EDITOR ~/.droid/.env && droid restart

# start the stack, then open Console at http://127.0.0.1:3000
droid

Writes docker-compose.yml and .env into ~/.droid/ and runs the stack from prebuilt images. droid starts it; droid down / droid status / droid logs control it. For a from-source developer install, add --source-install.

Prefer not to run the local stack yourself? Hosted deployment is also available through Unify Console ↗.

Architecture

01 orchestration

ConversationManager

Owns the session. Sees notifications, in-flight work, and user input. Makes a single deliberate decision per turn. Talks to the fast brain over IPC when voice is live.

02 planning

CodeActActor

Writes Python against typed primitives in a sandboxed session. One program per turn, with variables, loops, and composition. Discovery-first tool policy ensures the actor explores stored functions and guidance before writing new code.

03 domain

State Managers

Each manager owns its domain and runs its own async tool loop. ContactManager. KnowledgeManager. TaskScheduler. Each returns a live handle. Each can delegate further.

04 collective

Shared typed state

Managers can selectively share state across assistants. Cross-assistant coordination is opt-in per manager, scoped by workspace, and auditable at the boundary.