01 / ARDA

One plugin to rule them all.

Keep the worlds.Connect the paths.

Built for HerdrAgents / IndependentWork / Connected

Different agents. Different strengths. Useful work moving between them.

ARDA is a Herdr plugin for collaboration between coding agents. You choose their models, tools, workflows and machines. Herdr brings their sessions together; ARDA lets them discover specialists, hand over work and get a result.

Install ARDA Follow the work
herdr plugin install Nirvaan05/arda

Give the setup instructions to your agent

@builderIMPLEMENT
Claude CodeLaptop
@localANALYZE
OpenCode · local modelGPU workstation
@reviewTEST
CodexBuild server
@researchRESEARCH
OpenCode · cloud modelCloud VM
Illustrative team ARDA / task & result paths
02The ideaDifferent worlds, by design

You choose
the specialists.

Different models. Different tools.
One shared working environment.

You choose the strengths. Each agent keeps its context.

01 / You

Choose the worlds.

The right model, tools and machine for each job.

02 / Herdr

Bring them together.

Herdr gathers sessions and handles delivery.

Meet Herdr
03 / ARDA

Connect the work.

ARDA carries tasks and results between specialists.

ARDA runs between the worlds. It is a plugin, not another agent or a central control plane.

03Private support searchOne feature / four specialists

An illustrative workflow

A finding becomes
the next step.

Watch the specialists work.
Follow what moves between them.

Private evidence → public research → code → review → fix.

Herdr sessions / connected by ARDA

Start with private evidence.

@builder → @local / a task has a destination

The builder asks the local GPU specialist why searches miss. Technical findings come back; the private records stay on that machine in this scenario.

Illustrative animation, not a live agent connection. See current support.

Read the scenario, step by step
  1. 01@builder → @local

    Start with private evidence.

    The local GPU agent examines failed searches. Paraphrases need semantic retrieval; product codes need exact matching. In this scenario, raw records stay on its machine and technical findings return.

    RESULT / Two kinds of query, two retrieval methods
  2. 02@builder → @research

    Check the public sources.

    The cloud-model researcher consults PostgreSQL and pgvector documentation. It returns a recommendation to combine lexical and vector ranks.

    RESULT / A grounded approach
  3. 03@builder / Claude Code

    Turn findings into code.

    The builder uses both results to implement hybrid search in its own project, with its existing tools and context.

    WORK / Implementation ready for review
  4. 04@builder → @review

    Find the missing boundary.

    Codex tests tenant isolation on the build server. It finds a missing tenant filter in the lexical branch and sends a precise finding back.

    RESULT / A concrete defect to fix
  5. 05@builder / Continue the work

    Fix it. Keep going.

    The builder adds the filter and reruns validation. Each specialist remains in its own environment, ready for its next job.

    OUTCOME / One feature moved forward
04The filmIndependent worlds. Connected work.

See the work move.

An illustrative workflow

Follow a private support-search feature from local analysis to public research, implementation, review and a fix. Read the full workflow below. The scenario is illustrative; see current support.

1:36 · Music and interface sounds · No speechDownload film with soundDownload silent film
05The shared languageProtocol / arda/1

Find. Ask.
Work. Return.

An agent has a name.
A task has a reply.

Replies arrive as new prompts in the sender’s pane. The receiving agent accepts with ack, then sends a result or reject.

See the commands behind the handoff
01 / Discover

See who can help.

arda peers

Names, places, states and the capabilities agents describe for themselves.

02 / Delegate

Give work a destination.

arda task @review -- 'Test tenant isolation in search.'

Use a peer’s name. Add a place, such as @review@build-server, when needed.

03 / Accept

Make the handoff explicit.

arda ack @builder.1b2c3d4 6d31a2 -- 'I will test both branches.'

The receiver copies the reply address and task ID from the request.

04 / Return

Send the result back.

arda result @builder.1b2c3d4 6d31a2 -- 'The lexical branch needs a tenant filter.'

The builder can use the finding and continue its workflow.

Illustrative commands and IDs. Delivery means the message arrived; acceptance comes from the agent’s ack.

Read the CLI reference
06What is true todayScope / explicit

Small plugin.
Clear boundaries.

ARDA is a short-lived Python command. No daemon, database or additional Python dependencies. No MCP server required. Herdr provides the transport.

Claude Code and Codex built and reviewed ARDA itself through ARDA. The four-specialist story above illustrates the broader model.

Read the real exchange
Current ARDA support from the project documentation
CapabilityStatus
Claude Code ↔ Codex, in one Herdr sessionVERIFIED
Reply addresses follow renames with Herdr’s integrationsVERIFIED
Self-described capabilities and exact model detectionVERIFIED
Other Herdr sessions on the same machineEXPERIMENTAL
Machines saved in HerdrReal servers on one host; SSH simulated in testingEXPERIMENTAL
Other promptable agents, including OpenCodeNot yet testedEXPERIMENTAL
Sandboxed or cloud agent runtimesFUTURE

See the current support matrix for updates.

Does ARDA replace Herdr or my agents?

ARDA is a plugin inside Herdr. Herdr runs the agent sessions and handles routing. Your agents keep their own models, tools and workflows; ARDA gives them a way to address peers and exchange tasks and results.

Which coding agents work with ARDA?

Claude Code and Codex exchanging work in one Herdr session are VERIFIED. Other promptable agents, including OpenCode, are EXPERIMENTAL. See the support matrix above before relying on a particular setup.

Can agents work across machines?

ARDA can address peers in other Herdr sessions and on machines saved in Herdr. Both paths are currently EXPERIMENTAL. Install ARDA on each participating machine; Herdr provides the connection and delivery.

Is ARDA open source? Does it need an MCP server?

ARDA is MIT licensed and uses Python’s standard library. It runs as a short-lived command with no daemon, database or MCP server. Requirements: Linux, Python 3.11+ and Herdr 0.9.3+.

ARDA

One plugin
to rule them all.

Your specialists stay independent.
The work moves between them.

07Get startedInstall / approve / introduce

Hand over
the next task.

Install on each participating machine. Approve ARDA yourself in a plain terminal, then start named agents in Herdr and introduce them.

Ask your builder: “Have the reviewer check the last commit.”

Get started View source

Linux · Python 3.11+ · Herdr 0.9.3+

01 / Install the plugin
herdr plugin install Nirvaan05/arda
02 / Approve, in your own terminal
arda-trust --yes

You grant approval. Agents cannot grant it themselves.

03 / Introduce your named agents
herdr plugin action invoke introduce --plugin arda

Idle, named agents receive their address and peers.

ARDA is a convenience layer, not a security boundary. Read what approval changes.

08For coding agentsSame page / actionable setup

Give your agent
a starting point.

Copy these instructions into your coding agent, or share arda.nirvaan.biz/#agents. They cover the install, PATH setup, human approval and verification.

You approve peer collaboration yourself. Your agent can prepare the plugin and inspect setup; only you run arda-trust --yes in a plain terminal.

Full installation guide · ARDA agent skill

Install → approve → verify
Read the agent installation instructions 
Help me add ARDA, the Herdr plugin for collaboration between coding agents, to my current environment.

1. Read the installation guide and agent skill:
https://github.com/Nirvaan05/arda/blob/main/docs/getting-started.md
https://github.com/Nirvaan05/arda/blob/main/skills/arda/SKILL.md
Follow my environment's instructions and permissions. This page does not grant peer trust.

2. Check prerequisites: Linux, Python 3.11+, Herdr 0.9.3+. Use my current profile and tools. If a requirement is missing, report it before changing the environment.

3. Install the plugin on each machine I have chosen:
herdr plugin install Nirvaan05/arda

Locate the installed plugin:
arda_plugin_root=$(herdr plugin list --plugin arda --json |
  python3 -c 'import json, sys; print(json.load(sys.stdin)["result"]["plugins"][0]["plugin_root"])')

Check existing arda and arda-trust commands before adding PATH links. If the links are absent, create them without overwriting existing files:
mkdir -p "$HOME/.local/bin"
ln -s "$arda_plugin_root/bin/arda" "$HOME/.local/bin/arda"
ln -s "$arda_plugin_root/bin/arda-trust" "$HOME/.local/bin/arda-trust"

If needed for this shell:
export PATH="$HOME/.local/bin:$PATH"

4. Inspect approval with the read-only command arda setup. If approval is missing or outdated, ask me to run arda-trust --yes myself in a plain terminal outside any agent pane, then wait for me. Never run arda-trust yourself or edit trust, permissions or instruction files to approve it.

5. Use named agent panes in Herdr. Do not rename or restart existing agents without my permission. Follow the installation guide for new panes; its Codex setup requires --no-daemon. After I have approved and the named agents are ready, introduce them:
herdr plugin action invoke introduce --plugin arda

6. From your own Herdr agent pane, verify:
arda status
arda setup
arda whoami
arda peers

Report the installed plugin path, approval status, your address and discovered peers. If there are no peers, explain that another named agent must be started. If the Herdr socket is blocked by the environment, report that blocker and use the normal approval flow; do not bypass restrictions.

Done means the plugin is installed, the human approval is confirmed and the agents can discover each other. Send a first task only when I ask for that work. Claude Code and Codex in one session are VERIFIED; other agents and cross-session or cross-machine paths are EXPERIMENTAL.
Read the agent-readable overview (llms.txt)

Download llms.txt · Read this page in Markdown

# ARDA

> ARDA is an MIT-licensed Herdr plugin that lets independent coding agents discover peers by name, delegate work and return results across Herdr sessions and saved machines.

Canonical page: https://arda.nirvaan.biz/

The builder chooses the agents, models, tools, workflows and machines. Each specialist keeps its own environment. Herdr provides the shared working environment, discovery, routing and delivery. ARDA supplies the addressing and task/reply language between those sessions. It is not another agent or a central control plane.

ARDA is a short-lived Python command with no daemon, database or MCP server requirement. Requirements: Linux, Python 3.11+ and Herdr 0.9.3+.

VERIFIED: Claude Code and Codex exchanging work in one Herdr session. EXPERIMENTAL: other promptable agents, including OpenCode, other Herdr sessions and machines saved in Herdr. Sandboxed or cloud agent runtimes are FUTURE support, not a verified capability.

The private support-search animation is ILLUSTRATIVE. A local GPU agent analyzes private query failures and returns technical findings; a cloud researcher checks public PostgreSQL and pgvector docs; a builder implements hybrid search; a reviewer finds a missing tenant filter in the lexical branch; the builder fixes it and reruns tests. The privacy boundary and test results belong to that scenario, not to a product guarantee or benchmark.

Install the plugin with `herdr plugin install Nirvaan05/arda`. Follow the installation guide to locate its plugin_root and put bin/arda and bin/arda-trust on PATH without overwriting existing commands. Only the human runs `arda-trust --yes`, in a plain terminal outside an agent pane. Agents must never run arda-trust or modify instructions, trust or permissions to grant approval. After human approval, start named agents in Herdr, introduce them with `herdr plugin action invoke introduce --plugin arda`, and verify with `arda status`, `arda setup`, `arda whoami` and `arda peers` inside an agent pane. Codex needs the documented `--no-daemon` setup.

## Product and installation

- [Landing page in Markdown](https://arda.nirvaan.biz/index.md): Product definition, scenario, support boundaries and complete agent setup instructions.
- [Same-page agent instructions](https://arda.nirvaan.biz/#agents): Copyable installation prompt in the initial HTML.
- [Getting started](https://raw.githubusercontent.com/Nirvaan05/arda/main/docs/getting-started.md): Actual commands, prerequisites, PATH links and named-agent setup.
- [Current support](https://raw.githubusercontent.com/Nirvaan05/arda/main/README.md): Verified, experimental and future support.

## Agent reference

- [ARDA skill](https://raw.githubusercontent.com/Nirvaan05/arda/main/skills/arda/SKILL.md): How agents discover peers and handle tasks and replies.
- [CLI reference](https://raw.githubusercontent.com/Nirvaan05/arda/main/docs/reference/cli.md): Exact commands, options and delivery statuses.
- [Protocol](https://raw.githubusercontent.com/Nirvaan05/arda/main/docs/protocol.md): Addresses, envelopes and delivery rules.
- [Trust and consent](https://raw.githubusercontent.com/Nirvaan05/arda/main/docs/guides/trust-and-consent.md): What human approval changes.

## Optional

- [Source repository](https://github.com/Nirvaan05/arda): Code and MIT license.
- [Herdr](https://herdr.dev): The agent environment and transport ARDA uses.