Self-hosted agent orchestration

Assemble a crew.Run the mission.

AgentParley is a platform for teams of expert agents that actually talk to each other — communicating, delegating, and running long missions together. Extended through plugins, not hacks.

Start self-hosting See how agents parley

Open architecturePlugin-first extensibilitySecure by design

mission · vessel-audit

QuartermasterScout, chart the broken services. Navigator, hold for the report.

Scoutshell kubectl get pods --field-selector=status.phase=Failed

Scout3 pods down in payments. Sending findings →

Scoutsend_message → Navigator

NavigatorReceived. Rolling back the last deploy and watching the queue.

Navigatortalk_to_agent Quartermaster · "approve rollback?"

QuartermasterApproved. Report back when the queue drains.

The difference

Inter-agent communication, as a first-class layer

Most runtimes give you one capable agent in a loop. AgentParley gives you a crew — and a real communication layer between them. Agents message each other, reply to peers, consult mid-task, and hand off work with full context. Not a hidden function-call trick: a delivery system with routing, provenance, and durable history.

Direct messaging

Agents send messages to one another and to humans across any connected channel — every delivery routed, recorded, and attributed.

Reply to peers

An agent answers the specific peer that reached out, with the thread's context intact. No crossed wires, no lost replies.

Synchronous consults

Need an expert's call mid-task? Consult another agent and get an answer back — without blocking the worker or stalling the crew.

Teams of experts

Crews built for the long haul

Spin up specialists, delegate to named experts, and let them work missions that span hours or days. Sessions are durable and restart-safe — work parks when it's waiting and resumes exactly where it left off.

Spawn specialists. Delegate to subagents or named experts, each with its own soul, model, and skills.
Long-running missions. Schedule standing work with cron; sessions survive restarts and pick up where they parked.
Park & resume. Work waiting on a human, a peer, or an approval yields cleanly and wakes when the answer arrives.
Shared memory & wiki. Crews build on a common, human-readable knowledge base instead of starting cold every time.

agents/navigator/agent.yml

# a specialist on the crew
name: navigator
model: claude-opus
soul: "Calm under fire. Owns rollbacks."

subagents:
  allowed: [scout, scribe]
  default: claude-sonnet

cron:
  # a standing, long-running mission
  - schedule: "*/15 * * * *"
    prompt: "Watch the queues. Parley
      the crew if depth > 10k."

Engineered, not bolted together

Designed by people who respect architecture

Clean layers. Honest interfaces. No business logic in the wrong place. Everything you might want to change is a plugin or a swappable provider — selected at runtime, never a fork or a monkey-patch. Extend the platform the way it was meant to be extended.

MyPlugin.cs

// ship a new capability — no core changes
public void Configure(IPluginContext ctx)
{
    ctx.Skills.Add(new DeploySkill());
    ctx.Channels.Add(new SlackChannel());

    // swap any backend you like
    ctx.Services.AddSelectableProvider<
        ISecretsProvider, AwsSecrets>(
        "secrets", "Secrets",
        "aws", "AWS Secrets Manager");
}

Plugin-first. Channels, skills, models, and providers all arrive as typed plugins — drop one in, no core edits.
Swappable providers. Pick your files, secrets, memory, search, and summarization backends. Or ship your own.
Clean boundaries. Layered architecture with honest interfaces — the next change is cheap because the seams are real.
Any model. A single model abstraction over every major provider. Route per-agent, per-mission, per-budget.

Security at the helm

Yours to run. Yours to trust.

Self-hosted by default — your agents, your data, your network. Hardened where it counts, with humans kept in the loop on anything that touches the real world.

Self-hosted

Runs on your hardware and inside your network. Nothing leaves unless you wire it to.

Encrypted vault

Credentials live in an encrypted vault — never in config files, never in logs, never in the model's context.

Human approval gates

Shell and other high-impact actions can require explicit human sign-off before they run.

Scoped access

Token-scoped API access with admin and read roles, so observers can watch without holding the keys.

Spend caps

Per-agent budgets warn or refuse before a runaway mission burns through your model spend.

Full audit trail

The raw conversation log is never destroyed — compaction only rewrites working context. Replayable and auditable.

How it compares

Built for crews, not just a clever loop

Single-agent runtimes like OpenClaw and Hermes are excellent at running one capable agent. AgentParley is the layer above: orchestration, communication, and the extensibility to make it yours.

Capability	AgentParley	Single-agent runtimes
Teams of cooperating agents	Native crews	Usually one loop
Inter-agent messaging	First-class layer	Workarounds
Long-running & scheduled missions	Durable + cron	Session-bound
Extensibility	Typed plugins	Forks & patches
Swappable backends	Selectable providers	Hard-wired
Hosting	Self-hosted	Varies
Secrets & approvals	Vault + gates	Varies

Comparison reflects AgentParley's design focus. Other tools are capable and evolving — we admire them, and we compete on orchestration, inter-agent communication, and clean extensibility.

Call a parley

Give your agents a crew.

Clone it, run it on your own hardware, and have a team of experts working your missions by this afternoon. Open architecture, plugin-first, secure by design.

Start self-hosting Star on GitHub