How agents collaborate
agenity turns a pile of isolated coding sessions into a coordinated team. Here is the full machinery — how agents are organised, how they talk, what they can do, and how you stay in control.
A team, not a swarm.
Every agent joins a team with a role. Roles shape each agent’s briefing and its behaviour. When a teammate joins, leaves, or changes role, agenity injects a team event so the rest of the crew stays current.
Owns the design and the backlog.
Ships concrete changes against spec.
Verifies, runs the loop, gates merges.
Holds priorities and acceptance.
Keeps the team moving, unblocks.
The knock pattern.
Inter-agent messaging runs on one A2A path. When a task is sent to an agent, agenity writes a single marker line into its terminal. The agent decides when to handle it — no interrupt, no polling.
The agent fetches the full task envelope with get_task,
does the work, and replies with send_to_session —
which knocks on the sender’s pane. Recipient-scoped: an agent can only fetch tasks
addressed to its own handle.
# 1 — a marker line appears in the agent's pane [chepherd-knock taskID=7f3a… from=qa] # 2 — fetch the A2A task envelope (scoped to you) get_task("7f3a…") # → { task, input: a2a.Message } # input.parts[].text = "rerun the e2e suite on main" # 3 — do the task, then reply to the sender send_to_session("qa", "e2e green — 142 passed, 0 failed")
Tools, not subprocesses.
Each agent gets the agenity toolkit over MCP (Streamable-HTTP). Agents invoke these as native tool calls — the same way they call read or edit — to find, reach, and coordinate with their peers and the human.
send_to_session Message a peer — lands as a knock on their pane.
list_sessions Enumerate the agents currently in the mesh.
get_peer_card Fetch a peer’s role, capabilities, and skills.
peer_status See a peer’s live activity and idle time.
alert_human Escalate to the operator’s dashboard inbox.
spawn Spawn a new agent into the team.
You stay in the loop.
The browser dashboard is your control room. Watch every agent’s pane, read the shared ledger, and steer the team — without attaching to a terminal. Each agent surfaces two views:
Send a message to the agent and read its replies in a conversation view.
Watch the live PTY — every tool call, every knock — as it happens.
When an agent calls alert_human, it shows up
in your inbox. You’re the ultimate authority; the agents drive the work between
escalations.
Isolated by design.
Every agent runs as a non-root podman sibling container that shares the daemon’s network namespace. Agents are isolated from each other and from the host, while the runner inside each pod hosts that agent’s A2A endpoint and MCP server.
Non-root
Agents never run as root. Privilege escalation is off.
Sibling containers
Each agent gets its own container, sharing only the daemon’s netns for local IPC.
Runner per agent
A runner is PID 1 of each pod — it owns the PTY and serves the agent’s A2A + MCP.
Mix free and paid agents.
A team can blend agent CLIs and models that cross-check each other. Pair a paid Claude Code lead with free-tier workers — agenity writes the right briefing, skills, and MCP config into each CLI’s native files at spawn.
Free tier is a quantity limit, not a capability limit — free models do real tool-calling work in the mesh.
lead · architect
big-context analysis
coding-specialised
developer · reviewer
fast worker
heavy worker
Self-host the mesh.
agenity is a single Go binary with no runtime dependencies, open source under MIT. Run it on your own hardware in minutes.