Reasoning, not just prompting

Add a world_model node and your agent tracks typed beliefs, detects contradictions, and evaluates hypotheses from four generation sources before acting — instead of just asking the LLM and hoping.

Control that holds

Drop in a control_state node and your agent gains a five-tier resolver that governs every action — NORMAL → CAUTIOUS → BLOCKED. Diagnostic health vectors drive it; deadlock detection stops it escalating forever.

Verification with teeth

A verify_gate runs nine checks before every action. Pair it with reviewer_pass for adversarial review and contract validation before every return. Trust, but verify — and actually enforce it.

Recovery and learning

Add recovery for six named strategies, typed failure detection, and local vs global replanning. Attach exp_store and your agent reuses successful decompositions across future runs.

Start with state and reasoning

world_model, hypothesis_set, evidence_store, control_state, and a six-state task_graph — the infrastructure for an agent that thinks before it acts.

Add verification and recovery

verify_gate with nine layers, pre-execution review gate, six named recovery strategies via recovery, context compression, exp_store for cross-run reuse, and adversarial reviewer_pass.

Draw, compile, and deploy

Thirteen harness node types on the canvas, Langfuse tracing with harness-specific spans, framework adapters for all four runtimes, and end-to-end tests across every combination.

terminal

# 1. Generate secrets and configure your environment
./scripts/setup-env.sh

# 2. Start all services
docker compose up

What starts up

OpenAI

Add your OPENAI_API_KEY and use gpt-4o or gpt-4o-mini in any flow.

Anthropic

Add your ANTHROPIC_API_KEY and use claude-sonnet, claude-haiku, or claude-opus.

Ollama — free & local

Run mistral, qwen3, or qwen2.5-coder locally. No API key, no cost, no data leaving your machine.

Any custom model

Edit one config file to add any OpenAI-compatible model or endpoint — including self-hosted or fine-tuned models.

support-triage.flow.json

{
  "workflow": "support-triage",

  "nodes": [
    {
      "type": "llm_call",
      "prompt": "Classify severity"
    },
    {
      "type": "condition",
      "route": "high_priority"
    },
    {
      "type": "human_review"
    }
  ],

  "telemetry": {
    "provider": "langfuse"
  }
}

What you can build

agents

agent_roleagent_debate

flow control

conditionparallel_forkparallel_join

memory

memory_readmemory_write

composition

subgraphtransform

LangGraph

Python · JS · MIT

The production standard for stateful agent orchestration. LangGraph's graph model maps cleanly to FlowSpec — conditional edges compile without rewriting, and harness nodes like world_model, control_state, and verify_gate slot in as standard graph nodes with no translation layer.

• Checkpoint to Postgres or Redis — resume from any node after failure
• Full token and graph-update streaming
• Best fit: RAG agents, complex multi-step stateful flows

CrewAI

Python · MIT

The largest community for role-based multi-agent patterns. agent_role nodes map directly to CrewAI Crew, Agent, and Task — your canvas design becomes a crew without translation. parallel_fork for fan-out, memory_read for vector retrieval, and native vector store support included.

• Role-based agents compile natively — no wrapping needed
• Full memory (vector) support with top-k and threshold
• Best fit: specialist agent teams, research crews, parallel review

Mastra

TypeScript · Apache 2.0

The only TypeScript-native orchestrator with first-class harness support. Full HITL pause and resume, full streaming (tokens and graph updates), and native vector memory — all from the same FlowSpec that also runs on LangGraph or CrewAI if you switch later.

• Full HITL — pause, inspect state, resume from the canvas
• Full streaming and native vector memory
• Best fit: TypeScript / Node.js teams, JS-native stacks

Microsoft Agent Framework

C# · Python · Java · MIT

The merger of Semantic Kernel and AutoGen in one SDK, covering enterprise .NET, Python, and Java teams in a single adapter. agent_role and agent_debate map natively to AgentGroupChat; HITL runs via the _HitlPause exception pattern; durable state checkpoints via Dapr or Orleans.

• AgentGroupChat native — debate and role patterns compile directly
• Durable execution via Dapr or Orleans
• Best fit: enterprise .NET, Java, or Python teams

LangGraph Memory read, semantic search, caching

Mastra Human-in-the-loop, structured output

CrewAI Parallel agents, fan-out/merge

CrewAI Multi-agent, tool approval

MS Agent Framework Multi-agent debate, A2A protocol

REST endpoint

Any app can trigger your flow with a standard HTTP POST. No special SDK needed — a curl command or a fetch call is all it takes to run the full harness.

MCP tool

The Model Context Protocol (MCP) lets AI assistants call external tools during inference. Publishing as an MCP server means Claude Desktop, Cursor, and any MCP client can invoke the full harness — including its 11-layer control architecture — directly from a prompt, with no extra code.

A2A agent

The Agent-to-Agent (A2A) protocol is an open standard for AI agent interoperability. Publishing as an A2A agent means other agents — built on Google ADK, OpenAI Agents SDK, Claude Agent SDK, or any A2A runtime — can discover your harness via its Agent Card and delegate tasks to it without a custom adapter.

Embeddable canvas

Drop the visual editor into your own app with the @buildaharness/canvas npm package.

MCP · Model Context Protocol

MCP is Anthropic's open standard that lets AI assistants call tools and read context during inference. When Build A Harness publishes a harness as an MCP server, each harness is exposed as a callable tool with a typed input and output schema. Any MCP client — Claude Desktop, Cursor, the Claude Agent SDK — can discover and invoke it with no additional setup.

What this means in practice: a user in Claude Desktop types "summarise this contract and flag unusual clauses" and Claude automatically calls your content-moderation harness — complete with HITL controls, verify_gate, and Langfuse tracing — as if it were a local tool.

A2A · Agent-to-Agent Protocol

A2A is Google's open protocol for AI agent interoperability. An A2A agent publishes an Agent Card — a machine-readable description of its capabilities, inputs, and outputs. Other agents, regardless of their framework, can discover the card and invoke the agent over a standard HTTP interface without needing to know its internal architecture.

What this means in practice: a research agent built on Google ADK can delegate a "parallel risk assessment" subtask to your Build A Harness flow and receive a structured result — with neither agent needing a custom adapter. Compatible with Google ADK, OpenAI Agents SDK, Claude Agent SDK, and any A2A runtime.

track A · run & report

Run it against real flows

One docker compose up starts all nine services. Point it at a real flow — your actual use case, not a toy example. When something breaks, crashes silently, or produces wrong output, open a bug report with your FlowSpec JSON, the runtime you used, and the full error. The more specific, the faster it gets fixed.

Report a bug →

track B · shape the roadmap

Tell us what you need

Missing a node type? A harness feature that would change how you build? A runtime behaviour that doesn't map cleanly? Open a feature request. Describe what you're building and where Build A Harness falls short — concrete use cases carry far more weight than abstract asks. Phase priority is influenced by community demand.

Request a feature →

track C · build with it

Build a node pack or contribute a phase

FlowSpec v0.2.0 is stable for third-party node packs (@buildaharness/nodes/…). The full harness implementation is public and open for community contribution. The spec, adapter interface, and canvas package are all stable enough to build on today.

What is Build A Harness?

Build A Harness is an open-source (Apache 2.0) visual canvas for designing, testing, and deploying production AI agent harnesses. Draw the full architecture using 27 node types — 14 execution nodes plus 13 harness nodes that implement the complete 11-layer control architecture: world model, 5-tier control state, 9-layer verification, 6 recovery strategies, and cross-run learning. A single FlowSpec export compiles the same design to LangGraph, CrewAI, Mastra, or Microsoft Agent Framework without rewriting. Every run is traced automatically via Langfuse, HITL controls let humans pause and resume any flow, and one API call publishes the harness simultaneously as a REST endpoint, an MCP tool, and an A2A agent. Everything runs locally via Docker — no cloud account required.

What's the difference between a harness and a workflow?

A workflow routes prompts from node to node. A harness governs what the agent believes, what it's allowed to do, how it catches its own mistakes, and what it learns for next time. The 5-tier control state knows when to slow down or stop; nine verification layers check outputs before they land; recovery strategies handle failures systematically instead of crashing.

What is FlowSpec?

FlowSpec is Build A Harness's open, runtime-neutral JSON format for describing AI agent workflows. It is the intermediate representation that sits between the visual canvas and any execution runtime. A single FlowSpec file compiles to LangGraph, CrewAI, Mastra, or Microsoft Agent Framework without rewriting. FlowSpec v0.2.0 is stable and open for third-party node packs (@buildaharness/nodes/…).

Why a runtime-neutral FlowSpec?

It decouples the canvas from any single runtime. Adding a new runtime is one adapter file, and canvas features — HITL, observability, versioning — stay independent of your runtime choice. One flow runs across all four supported runtimes without rewriting.

Why these four frameworks?

LangGraph is the production standard for stateful agents. CrewAI has the largest audience for multi-agent team patterns. Mastra is the only TypeScript-native orchestrator with first-class support. Microsoft Agent Framework merged Semantic Kernel and AutoGen, covering enterprise .NET and Python users.

Is it open source?

Yes — Apache 2.0. The canvas, adapters, FlowSpec, and the full harness implementation are all open.

Does it require a cloud account?

No. Everything runs locally via Docker — ./scripts/setup-env.sh && docker compose up. You only need an LLM API key, or skip it and run a free local model with Ollama.