Agent Playground is liveTry it here → | put your agent in real scenarios against other agents and see how it stacks up

The Big Picture

Declare what your multi-agent system should do, run it through a contract-based runtime, and you get auditable, reproducible behavior and governance that can block or allow actions before they happen.

The Evidence

A spec-first approach—where every agent, tool, and governance rule is declared before execution—lets teams separate intent, control, and infrastructure so behavior can be validated independently of deployment. A contract-driven runtime enforces policies at every boundary (model calls, tool calls, state, communication) so unauthorized actions are blocked before they execute and every decision is recorded. The lab layer replays and perturb runs (fault injection, deterministic LLM replay, backend swap) to attribute behavior changes to concrete specification differences rather than implementation drift. Runtime overhead for governance is tiny compared with model time, making pre-execution checks practical in production-like setups.

Data Highlights

1LLM processing accounts for more than 99.8% of total time in a full production stack, so runtime governance adds negligible latency relative to models.
2All governance evaluations together contribute about 0.12% of total execution time for a nominal query under the full stack.
3Individual governance checks are stable at roughly 1.4 milliseconds per check across tested scenarios.

What This Means

Engineers building multi-agent applications who need reliable, auditable behavior—because they can validate logic independently of deployment and prevent undeclared actions. Technical leaders and operators who must enforce budgets, approvals, or safety constraints in production will get mechanized governance and replayable evidence for compliance. Researchers benchmarking coordination patterns can run controlled, comparable experiments by swapping overlays or backends without changing agent logic.
Not sure where to start?Get personalized recommendations
Learn More

Key Figures

Figure 1 . MAS-Lab layers.
Fig 1: Figure 1 . MAS-Lab layers.
Figure 3 . MAS-Lab flow: from experiment specifications through MAS-OS execution and control to Labs pipeline steps producing results artefacts.
Fig 3: Figure 3 . MAS-Lab flow: from experiment specifications through MAS-OS execution and control to Labs pipeline steps producing results artefacts.
Figure 4 . Typical post-execution pipeline flow. Typed artefacts flow through reusable steps; evaluation and visualisation steps are decoupled from execution.
Fig 4: Figure 4 . Typical post-execution pipeline flow. Typed artefacts flow through reusable steps; evaluation and visualisation steps are decoupled from execution.
Figure 5 . Lab 1, Exp 1.1 (reasoning patterns): latency– quality score trade-off. Light points are individual runs; large markers are per-scenario means with 95% confidence intervals on both axes.
Fig 5: Figure 5 . Lab 1, Exp 1.1 (reasoning patterns): latency– quality score trade-off. Light points are individual runs; large markers are per-scenario means with 95% confidence intervals on both axes.

Ready to evaluate your AI agents?

Learn how ReputAgent helps teams build trustworthy AI through systematic evaluation.

Learn More

Yes, But...

Experiments in the paper are small and illustrative; large-scale, highly-distributed deployments may expose additional system-level challenges not fully evaluated here. The approach depends on complete and correct specifications—missing declarations will cause the runtime to block actions rather than silently allow them. While governance overhead is minimal compared to model time, total system cost and complexity increase with richer contract libraries and long-lived traces. specifications

Methodology & More

MAS-Lab introduces a three-layer, spec-driven stack to make multi-agent systems testable and trustworthy. Start by writing a declarative specification that names agents, tools, models, workflows, and governance overlays (budgets, approvals, capability toggles). At runtime, a contract-based operating system binds those declarations to per-agent finite control charts (implemented as composed Mealy machines) that enforce policy-before-execution: every outward action follows open → govern → record → execute → close, and undeclared or unauthorized operations are blocked. All boundary crossings (model calls, tool calls, delegations, state access) are recorded as ordered events so traces are auditable and replayable. govern finite control charts
Avoid common pitfallsLearn what failures to watch for
Learn More
Credibility Assessment:

ArXiv preprint with one author showing a moderate h-index (11) and others low; mix suggests a recognized but not top-tier researcher group.