Agent Harness Lab
GitHub Run locally

Open source · Local-first · MIT

Agent workflows you can measure, pause, and prove

Token-Efficient Agent Harness Lab is a self-hosted control plane for studying and operating event-sourced agent systems — with deterministic budgets, regression scorecards, adaptive routing evidence, and an operator dashboard that refuses to invent facts.

Star on GitHub Get started in minutes
  • 1600+ Rust tests
  • Fail-closed by design
  • SQLite local default
  • Rust + TS + Python

Built for people who care about the bill and the audit trail

Agents are cheap to start — expensive to trust

Most stacks optimize demos. This lab optimizes evidence: what ran, what it cost, what changed, when to stop, and how you prove it again next week.

Token spend without scorecards

Providers invoice tokens. Without deterministic regression reports, “efficiency” is a vibe — not a hash-bound artifact you can recompute offline.

Automation without a kill switch

Unbounded agent loops burn money and trust. Policy-gated auto-pause, auth scopes, cost caps, and audit logs keep autonomy inside explicit rails.

Dashboards that invent zero costs

If pricing is not configured, the system says so. Sparse or tampered evidence returns insufficient_evidence — never a silent green check.

What you get

A research-grade harness that already ships production-shaped surfaces — not a slide deck.

◎

Token Efficiency Regression Lab

Deterministic registries, batch recomputation, trends, SQLite/PostgreSQL persistence, and read-only API/SDK/Dashboard history. Report-only by design.

▣

Budget intelligence & auto-pause

Forecasts and anomaly findings with coverage, confidence, and reason codes. High-confidence pause only through existing authority — idempotent and reversible.

⇄

Adaptive fusion routing

Bounded multi-endpoint routing, experiments, promotion, and operator evidence — activated through a trusted-local profile, not ambient magic.

⚙

Dispatch kernel + agent runtime

Event-sourced workflow control, bounded multi-agent semantics, mailbox/step executors, and operator read models sealed through AR-6.

✎

Real repository output (V2)

Auditable patch/PR production against real git targets with verification evidence — for labs that want more than mock JSON.

⬡

Wire contracts that don’t drift

Codegen across Rust, TypeScript, and Python with CI drift checks. One wire truth, three SDK surfaces.

Stack that prefers boring reliability

Rust engine as sole runtime/API/storage. Static dashboard. Optional PostgreSQL. Docker when you want it — not required for first run.

  • Engine — Rust · axum · SQLite default
  • Dashboard — Next.js static export · Bun
  • SDKs — TypeScript + Python readers
  • CI — multi-job green path · ~7–9 min
  • License — MIT · public research lab
Dashboard
TS SDK
Python SDK
HTTP · wire contracts
Rust engine · dispatch · budget · adaptive · audit
app-owned local state
SQLite
PostgreSQL
Backups

Quick start

Run the control plane on loopback. No cloud account required.

1. From source

git clone https://github.com/Igzela/token-efficient-agent-harness-lab.git
cd token-efficient-agent-harness-lab
cargo build -p engine
cd dashboard && bun install --frozen-lockfile && bun run build:static && cd ..
ACP_DASHBOARD_DIR=dashboard/out cargo run -p engine
# Open http://127.0.0.1:8080

2. Docker (optional)

docker run -d -p 8080:8080 -v acp-data:/data \
  igzela/agent-control-plane:latest

Or docker compose --profile combined up -d from a clone.

3. Verify the stack

bash scripts/verify_rust_typescript_stack.sh
uv run --no-project python scripts/acp_local_doctor.py

Primary cutover check: wire drift, Rust, TS SDK, dashboard, live smoke routes.

Ready to dig in?

Architecture book, runbook, and packetized roadmap live in the repo.

Open repository Architecture book

Honest boundaries

Promotion without false promises. Read this before starring for “hosted multi-tenant agents.”

This project is

  • A local / small-team self-hosted harness
  • Deterministic, evidence-first, fail-closed
  • Useful for research, internal ops, and reproducible cost studies
  • MIT open source with public CI

This project is not

  • A cloud SaaS or multi-tenant product
  • A promise of container/VM isolation
  • An always-on free provider proxy
  • A system that invents pricing or success when evidence is thin