AGENTIX · ENGINEERING LOGARCHITECTURE / 2026
Architecture5 min read

Contracts before code: typed schemas for honest agents

32 JSON-schema contracts and 1,000+ offline tests keep multi-agent output verifiable — independent of which coding agent produced it.

By Agentix Tech · Engineering log

A phased agent lifecycle where every phase's structured output is validated against 32 typed JSON-schema contracts before the next phase may start

The failure mode of a multi-agent system is rarely the model being wrong in an interesting way. It is the hand-off between agents being vague. One agent writes a plan as prose, the next agent interprets that prose, the third builds on the interpretation — and by the time anyone looks at the result, the original intent has been re-written three times by three different readers. Nobody lied. Nobody was careless. There was simply nothing that said what shape the output had to be.

Autoagentix Dev — our provider-agnostic development framework — is built on a different premise: define the contract before the work runs, and verify the output against it before the next phase starts. It is contracts before code, and it is the reason the framework holds together when the model underneath it changes.

32JSON-schema data contracts
1,000+offline tests verify them
8coding agents, one lifecycle

The hand-off is where systems drift

Autoagentix Dev detects which coding agent is already installed in a repository — Claude Code, Codex, Cursor, Copilot, Gemini, OpenCode, Aider or Devin CLI — and runs development through a phased lifecycle: init, plan, implement, testing, monitor, with a human approval gate between phases. It never supplies a model of its own. That design choice is deliberate, and it creates the problem the contract layer exists to solve: if the intelligence can be any of eight providers, the output style can vary across eight providers too.

The framework’s answer is that every phase produces a defined shape, not free text. 32 JSON-schema data contracts specify what each phase must output, and the framework validates each phase’s structured output against its contract before the lifecycle proceeds.

Coding agent any of 8 providers phase output Structured output defined shape, not prose validate 32 JSON-schema contracts schema check per phase 1,000+ offline tests pass Human approval gate then next phase fail: phase rejected, back to the agent A phase that fails its contract never reaches the next agent.
Verification sits between phases, where you control it — not inside the model, where you do not.

Free text cannot be audited

The distinction is easiest to see side by side.

Free-form hand-off Contract-checked hand-off
Shape Whatever the model wrote that day 32 JSON-schema definitions
Verification Read by eye, once 1,000+ offline tests, every run
Provider change Output style changes with it Identical verification either way
Failure surfaces In the next agent’s behaviour At the gate, before hand-off

A plan written as prose can be misread. A plan validated against a schema either has the required fields or it does not, and the framework checks before the implementing agent ever sees it. When the check fails, the phase is rejected — back to the agent, not onwards to the next consumer of the output. The cost of a wrong turn is paid at the cheapest possible point.

This matters more as agent counts grow. Two agents exchanging free text have one misunderstanding to manage. Five agents in a pipeline have four hand-offs, and each one compounds the previous drift. Contracts turn that from a chain of interpretations into a chain of verified facts.

Learning the repo first, verifying every phase

The contract layer sits alongside two other habits that keep the framework honest. Before any phase runs, six knowledge-base scanners read the codebase across Python, TypeScript, JavaScript, Go, Java and C#, so the work starts from what is actually there rather than what the model assumes. And throughout, a tracker/PR/bugfix/learning layer keeps work items, fixes and learnings in sync as the repository evolves.

If the output can come from any of eight providers, you cannot rely on the model to be consistent. You define the contract each phase must satisfy and verify it independently of which agent produced it.

Being plain about maturity: Autoagentix Dev is v0.0.1 and in active development, and we claim no measured production outcomes. What the design already delivers is a lifecycle whose verification does not move when the provider does — the contracts and the gates belong to you, not to whichever model is in fashion this quarter.

If you are wiring agents into a development workflow this quarter, the useful question is not how capable the model is. It is what stands between one agent’s output and the next agent’s input.

See the contracts, lifecycle and detection detail on the Autoagentix Dev product page. To talk through how this fits your repository, book a call at cal.com/agentix-tech or reach us via /contact.

Work with us

Building a system
that has to hold up?

Tell us what you're building. We'll tell you how we'd architect it, what the eval harness would cover, and what production deployment involves.

AGENTIX TECH · engineering log · Architecture