OS-008 · Agent Harness Protocol

There are many agent harnesses.
traaviis builds yours

TRAAVIIS is the harness engineer. Give it a goal and it forges the harness for that job — routing each prompt to the right model tier, orchestrating sub-agents across the [&] Protocol stack, composing their results into one pipe, and stamping every action with a governance verdict. Pick a goal below and watch it build.

route a prompt spawn the sub-agents compose the results stamp a verdict
traaviis — orchestrating scripted demo · click a goal
goal ›

The orchestration above runs scripted, locally — no model is called from this page. In the CLI, traaviis routes each step to your configured provider and MODEL_TIER (local_small ▸ local_large ▸ cloud_frontier); the tools it drives never call models themselves.

$ npm install -g traaviis · or npx traaviis · traaviis.com
retrievepull prior context from Graphonomous
routepick the model tier & sub-agents
actrun commands over the stack
learnreport outcomes back to memory
consolidatemerge into one answer + verdict
Composable

Every sub-agent writes to the same pipe.

What the orchestrator hands each sub-agent is a command line, and what comes back is a structured value — not text. So results compose with | exactly like a shell: generic combinators (where, map, each, count) work with any command without re-parsing. Build a pipeline and watch it stream — this is the real engine.

traaviis — compose click stages to build the pipe
& traaviis ›
compose ›
Extensible

Teach the engineer a new move.

There is no plugin API beyond "register a command." Drop a .mjs in ~/.traaviis/extensions/ and it joins the same registry the built-ins use — instantly available to you, to a pipe, and to the orchestrator's sub-agents. Declare a capability and the built-ins it needs, and it composes with everything else. Register the example and run it:

// ~/.traaviis/extensions/deploy.mjs
export default function (h) {
  h.command({
    name: 'deploy',
    capability: 'ops.deploy',        // resolvable by capability
    needs: ['build'],              // composes with a built-in
    async run(h, [name], input) {
      await h.invoke('build', [name]);  // reuse another command
      return { deployed: name };        // pipe-able output
    },
  });
}
command registry · live
Pluggable

Swap an implementation, not the kernel.

Sub-agents, providers, and governance backends are reached by capability, never by hard wiring. Pick a provider for each capability below and watch the harness re-resolve — and flag any unmet need. /plugins reports exactly this at runtime.

interactive

REPL with pipes, completion, and a session tree.

print

traaviis status — run once, exit.

json

traaviis --json products — structured for CI & agents.

rpc

traaviis --rpc — JSONL in, events out: drive it from an editor or another agent.

Governed

Every action clears a verdict, not a popup.

Before the orchestrator lets a sub-agent act, the action is piped through the box-and-box kernel, which returns a certificate: floor-then-gradient over an un-weakenable safety floor, feasible ▸ permitted ▸ best. The verdict is a value you can pipe, attach to the session tree, and gate CI on — so autonomy never outruns governance.

certificate · govern.validate decision · exit 0
actiondeploy box-and-box (from orchestrator)
ladder feasible permitted best
floorheld — no rule weakened
Primitives, not features

A kernel you can hold in your head.

The engineer is small on purpose: a command registry, a pipe engine, capability manifests, a session tree, output modes — plus the orchestration loop that drives them. Everything else is an extension. Here's what's deliberately left as a seam, not baked in.

No hidden agents

The orchestrator's fan-out is visible — every sub-agent prints in front of you.

No model in the tools

The harness routes prompts; the commands it drives never call a model.

No permission popups

Governance is a verdict + certificate — see above.

No baked-in MCP

Bridge to MCP with an extension when you actually want one.

No plan mode

Plans are session-tree nodes you export and replay.

No magic

Zero runtime deps, readable ESM. Read it. Fork it. Own it.