Advanced Research Prototype

Agent Graph Orchestration
for the Developer Workstation.

Graphs that run the loops. An entropy sink for agent fleets.

A RAAD — Rapid Agent Application Development — environment that runs on your machine. Compose coding agents, tools, and human approvals into durable workflows. Code-first or Model-first Graphs, provider-agnostic, and small enough to start on a Raspberry Pi.

See it live ↓ Open the browser demo →

curl -fsSL https://nanobpm.io/install.sh | sh

One command: installs the CLI, hires your coding agents, and brings up a Nano engine, a workforce, and the app.

Or set it up by hand

npm i -g @camunda8/cli c8ctl load plugin c8ctl-plugin-nano c8ctl nano start

Just the engine. See the full manual sequence in Get started with c8ctl →

Code-first or Model-first Graphs.

One app — two authoring surfaces, the same engine.

A loop where local coding agents iterate to convergence against GitHub Copilot’s adversarial PR reviews — authored as code.

import { defineFlow, envelope } from "@nanobpm/workflow";

// Typed data envelopes — lifted into the emitted BPMN, so the generated model
// stays ejectable to the modeller with its contracts intact.
const PrRef = envelope("PrRef", { prKey: "string" });
const Diff = envelope("Diff", { diff: "string" });
const Verdict = envelope("Verdict", { verdict: "string" });
const Merged = envelope("Merged", { merged: "boolean" });

// urban-pr-review — an agent convergence loop, authored as code.
// The same app the Model-first tab runs live on the wasm engine.
export const prReview = defineFlow(
  "urban-pr-review",
  {
    fetchDiff: { in: PrRef, out: Diff },
    "senior:pr-review": { in: Diff, out: Verdict },
    merge: { in: PrRef, out: Merged },
  },
  (w) => {
    w.run("fetchDiff", async (job) => ({ diff: await gh.diff(job.variables.prKey) }));

    // A hired coding agent (c8ctl nano hire copilot) reviews as a durable worker.
    w.run("senior:pr-review", async (job) => ({ verdict: await agent.review(job.variables.diff) }));

    // Durable wait — survives a crash or forced reboot, resumes on the signal.
    w.signal("review-ready", { correlationKey: "prKey" });

    w.run("merge", async (job) => ({ merged: await gh.merge(job.variables.prKey) }));
  },
);

Nano derives the executable model, the job types, the message correlation, and a generic worker. You write steps and handlers — nothing else.

The real urban-pr-review BPMN model, executing live on the WebAssembly build of the engine — no server. Or open it full-page →

Reasoning is an LLM concern. Durability isn't.

A primary agent orchestrating subagents is a good pattern — reasoning about what to run next is exactly what an LLM is for. But holding the dependency graph and the run state in context is not. That's durable state living in the most volatile, most expensive place you have: one compaction and the plan is gone; one overnight reboot and the run dies, the state with it, the tokens re-spent. And every token spent bookkeeping what's done, what's blocked, what's next is a token not spent on the code. It degrades both. Nano takes the orchestration out of context — durable, inspectable primitives that drive work to convergence instead of drift. The agent designs the graph; the engine runs it.

DRY your agent SDLC

Declare durable steps with w.run and durable waits with w.signal. Nano derives the model, job types, correlation, and workers — one source of truth, no copy-paste orchestration across every workflow.

Author once. Nano derives the rest.

Code-first or Model-first Graphs

Write the workflow as code, or draw it as BPMN — the same durable engine runs both. Switch surfaces without re-platforming; the model and the code are two views of one runtime.

Same engine. Same app. Your choice of surface.

Durable by default

Survives crashes and forced reboots. On restart a workflow resumes at the exact step it left off — completed steps aren't replayed. Delivery is at-least-once: make your activities idempotent (e.g. with idempotency keys) and they run effectively once.

SIGKILL → cold restart → completed steps are never replayed. With a negative control.

Provider-agnostic. Mix frontier with local.

Blend frontier models with local LLMs — on one workstation or across many. Route the expensive steps to a frontier model and keep the rest private and free. Bring the coding harness you already use:

GitHub Copilot Claude Code Pi Open Coder Little Coder and more

Polyglot by design. Meet your stack.

Because Nano speaks the Camunda 8 REST API, it inherits Camunda's polyglot SDK surface — drive workflows and workers from the language your team already ships in, with first-class Camunda 8 SDKs across the stack — plus the wider ecosystem of tooling built on that API, which works against Nano unchanged:

TypeScript Java Rust Python C# Go

Add an agent + coding harness to your workforce.

Turn any interactive CLI agent harness into a durable Nano job worker. Hire persists an agent profile; work polls the cluster and runs jobs through it.

c8ctl nano hire copilot c8ctl nano work copilot

1
Hire. Persist an agent profile — a name, a rank, and the CLI command (e.g. copilot) that backs it.
2
Work. The harness polls for jobs and runs them, so a coding agent becomes a first-class, durable worker in your orchestration.
3
It just resumes. Every run is an ordinary durable Nano instance — crash-resume is implicit, and you never think about the journal.

How Nano compares.

The agent-tooling landscape spans desktop IDEs, terminal runtimes, and in-model scripting. Nano Workforce is the durable engine underneath — the one that keeps running when the machine doesn't.

Capability	Nano Workforce	Orca	Herdr	Claude Dynamic Workflows
What it is	Durable agent-workflow engine	Desktop orchestrator IDE	Terminal runtime for agents	In-Claude subagent scripting
Orchestration lives in	The durable graph	You, in the GUI	You / agents via socket	The JavaScript the model writes
Authoring surface	Code-first & Model-first (BPMN)	Manual, worktree GUI	Interactive + socket API	A script Claude writes
Survives crash / reboot	Yes: Journal-backed step resume	Partial: Scrollback only	Partial: Terminals reattach	Partial: Resumes in the session
Human approval steps	Yes: First-class durable waits	No	Partial: Flags a blocked agent	No
Agent harnesses	Provider-agnostic	Codex, Claude, OpenCode, Pi	Claude, Codex, Cursor, Grok…	Claude only
Frontier + local models	Yes: Mix both on one box	Partial: Via the harness	Partial: Via the harness	No: Anthropic only
Headless / server / CI	Yes: Engine + Camunda 8 REST	No: Desktop app	Partial: Background server	Partial: Inside Claude Code
Distributed fleet	Yes: Any mix of hardware, local to fleet	Partial: One desktop (+ SSH box)	Partial: One host, reattach over SSH	No: Single machine
Footprint	Small — runs on a Raspberry Pi	Electron desktop	One Rust binary	Claude Code
License	Free to evaluate & personal use	MIT	Apache-2.0	Proprietary

Overlapping but distinct: Orca and Herdr host the interactive terminals your agents run in, and Nano can drive those same harnesses as durable workers. This grid maps each tool to the job it leads on. Sourced from each project's own docs; corrections welcome.

RAAD.
Rapid Agent Application Development.

An Advanced Research Prototype for agent graph orchestration on the developer workstation. Start in one line.