Contracts earn trust.

the thesis

AI amplifies the architecture it finds

Discipline compounds. Confusion accelerates. Each layer makes the one above it safe to speed up.

the talk in one slide

Ownership, agreed and automated

The federated estate - everything is integration

Federation multiplies the seams

the cost - paid on every deadline

The integration tax

The QA bottleneck isn't a people problem - it's structural: nobody owns the space between the services.

the premise - contract-first design

The contract is the agreement

Producer and consumer agree the contract. Not the framework, not the language, not the vendor.

Design and documentation are mastered in the contract - an OpenAPI spec agreed before a line of service code exists. The design arguments, the domain taxonomy included, are settled here - not in code review. That makes it the one artefact every team can share, whatever they build with.

discovery - before any tooling

How we drew the boundaries

Design isn't a phase you schedule - it's deciding what the words mean before you decide what the code does.

case study

Harmony - a federated integration layer

Every seam is a contract. We expected them to help with testing - they became something more.

scaling development - stub while you build

Decoupled, yet aligned

The contract owns the seam - and your test environment is a set of contracts, not a shared server. Every team moves at its own pace against the same truth.

scaling development - automation

The central contract pipeline

Every contract change runs the same gauntlet. A breaking change fails the build - before it can break a team.

central contract repo

The pipeline in production

one push  ·  3m 57s  ·  a monorepo of contracts  ·  matrix scoped to what changed

Contracts are code - branched, reviewed, built, published. Impact-scoped, so only what changed is re-verified.

the shift - test specs to trusted assets

Architectural assets that can't rot

Started as a testing convenience. Became the assets teams trusted - contracts are executable documentation, and if the docs are wrong, the build fails.

ways of working

Everything is a pull request

in the pipeline

MicroContext spec review on every PR

Not a gatekeeper - a feedback loop. Humans keep the judgement calls.

- "MicroContext": Mehdi Medjaoui, APIdays - a context-specific agent, scoped the way we scope microservices. This one's world is our standards and contracts - never the codebase.

adoption

No slides. Just running code.

To earn adoption we ran a development workshop: containers, scripts, and working pipelines - a clear, testable architectural style teams could take away and make their own.

the AI world - neurosymbolic AI

The agent proposes. The contract permits.

Probabilistic reasoning inside, logical constraints outside - that's neurosymbolic, in practice.

new word, same artefact - the ontology is the contract you've been publishing all along

Trust the artefact, not the author - human or agent.

- a framing echoed in Frank Coyle's talk "Why Agentic Systems Need Ontologies," AI Engineer World's Fair

the agentic economy

Contracts are the index to your organisation

Probabilistic reasoning in the middle. Deterministic contracts at both ends.

- built and running: an AI query assistant over the federated graph. SDL in, query out, UI generated from the deterministic result.

the agentic economy - in practice

The hardest query language is now plain English

query($clientId: String!) {
  clientProfile(clientId: $clientId) {
    name
    addresses { line1 city zipcode
      country { name code } type }
  } }

taking it home

Start small, expand on proof

One seam, one week - and every contract you publish is infrastructure for the agentic economy.