A guide for context-efficient, agent-built software.

Specify behaviour.
Generate the build.

Keep the specification authoritative and the implementation replaceable. Define what must happen, generate bounded artifacts, verify the assembled build, then accept a release.

Where to start See the worked example

AXIO

Required behaviour.Authority, constraints, acceptance criteria, tests.

CONTRACT

Bounded, testable work.One artifact, explicit interfaces and pass/fail criteria.

MORPHIC

Generated implementation.Replaceable artifacts assembled into a release.

  1. Axiom
  2. Contract
  3. Morphic
Glossary of key terms
AXIO
The authoritative model of required behaviour, constraints and acceptance criteria.
Contract
A bounded, self-contained task defining one artifact, its interfaces and acceptance criteria.
Morphic
The generated, replaceable artifacts that implement the model.
Artifact
A named output file or component with defined boundaries and interfaces.
Scope
The work boundary: what to create, how it connects and how it will be checked.
Acceptance criteria
Observable pass/fail conditions used to verify required behaviour.
Candidate
An assembled set of generated artifacts awaiting independent verification and acceptance.

Where to start

Define → Scope → Generate → Verify → Accept

The change contract carries exact requirements into bounded artifact generation.

  1. DefineRefine the model
  2. ScopeSet boundaries and acceptance criteria
  3. GenerateCreate scoped artifacts
  4. VerifyCheck independently
  5. AcceptApprove the build

Failed checks? Refine the model and regenerate affected artifacts only.

Define the change

Resolve the request against Axiom. The coordinator defines required behaviour, interfaces, artifact boundaries and measurable acceptance criteria.

Scope bounded contracts

Split the model into self-contained work units with exact artifact ownership, shared interfaces and observable pass/fail criteria.

Generate scoped artifacts

Each worker receives a self-contained contract for one artifact and returns only that artifact. Generation produces a candidate, not an accepted build.

Verify the assembled build

The orchestrator assembles artifacts and independently checks their contracts, interfaces and required integration behaviour.

Accept an immutable release

Commit only the accepted Morphic build. Keep working Axiom outside Git. A correction produces a new candidate and release.

Worked example

Build a product catalogue page

One requested page can be defined as a set of bounded, coordinated artifacts.

Request

Provide a product catalogue page with product data, responsive presentation and a clear empty state.

Axiom

Define page behaviour, content, data shape, accessibility constraints and acceptance criteria.

Acceptance

Assemble the artifacts, check interfaces, empty and populated states, accessibility and required regression behaviour.

Expand: decompose the page into artifact contracts

The coordinator defines the shared interfaces in Axiom, then issues one self-contained contract per artifact.

catalogue/ ├── index.html ├── styles/catalogue.css ├── scripts/catalogue.js └── data/products.json

Shared interface map, attached to each relevant contract: data/products.json is a JSON array. Each object has required string fields id, name, description, and url; image is a string or null. The URL is a relative page path or HTTPS URL. HTML provides #product-list (a ul), #empty-state (a hidden status paragraph), and #load-error (a hidden alert paragraph). Each product list item uses .product-card, with .product-image (optional), .product-name, and .product-description. Serve over HTTP(S), not as a file: URL.

Data contract

Write valid UTF-8 JSON only to data/products.json. Output an array matching the schema. Empty array is valid. Required fixture:

[{
  "id": "mug-01",
  "name": "Axiom Mug",
  "description": "Ceramic mug, 300 ml.",
  "url": "products/mug-01.html",
  "image": null
}]

HTML contract

Write only UTF-8 index.html. Include <main>, one <h1>, <ul id="product-list">, <p id="empty-state" role="status" hidden>No products found.</p>, and <p id="load-error" role="alert" hidden>Products could not be loaded.</p>. Link styles/catalogue.css and deferred scripts/catalogue.js. No inline CSS/JS.

CSS contract

Write only styles/catalogue.css. Style exactly the interface-map IDs/classes. Product list is one column below 40rem and three columns at or above 40rem. Keep status and alert content readable. Define visible and hidden states using the HTML hidden attribute. No markup or script.

JavaScript contract

Write only scripts/catalogue.js. Fetch data/products.json; reject non-OK responses, non-arrays, or records with invalid field types. For each record create an li.product-card, optional image, name link and description; set data with DOM methods and textContent. Empty array shows only the empty status. Success hides the alert. Any fetch/schema error clears the list, hides empty status, and shows the alert. Do not change contracted IDs/classes.

Assembly: the orchestrator places outputs at exact paths and checks every interface. HTML and JavaScript consume the data schema; HTML and CSS share IDs/classes; HTML loads both local files. Each worker receives its artifact contract and attached interface map, never repository access.

Independent acceptance: verify schema handling, populated and empty states, markup and asset references, responsive layout, accessibility, and the composite page criteria. Failed criteria go back to Axiom for refinement before affected artifacts are regenerated.

Implementation kit: trace one requirement to release

This illustrative example follows requirement CAT-02 through a single generated artifact. Workers receive only their contract and attached interfaces.

Axiom requirement

CAT-02
Given a catalogue with no products,
show “No products found.”
Keep the empty state hidden
when products are present.

Acceptance: the empty message is visible only for an empty catalogue.

Artifact contract

artifact:
  catalogue/index.html
format: HTML, UTF-8
implements: CAT-02
interfaces:
  #product-list
  #empty-state
references:
  catalogue.css
  catalogue.js
constraints: no inline code
output: this file only

Contract fields and worker limits

Generated fragment

<ul id="product-list"></ul>
<p id="empty-state" role="status" hidden>
  No products found.
</p>

The HTML supplies the contracted hooks. The script artifact implements the state change; the HTML worker does not implement script behaviour.

Independent verification

  • CAT-02: empty data shows the message; populated data hides it.
  • Interface: HTML IDs match the script contract.
  • Assembly: stylesheet and script paths resolve; the page remains accessible.

Evidence: the orchestrator assembles the outputs and records each criterion as pass/fail against the candidate. The worker does not run checks. A failure returns to Axiom for refinement, then only affected artifacts are regenerated and rechecked.

release: catalogue-1 (illustrative)
status: accepted
includes: assembled Morphic artifacts
records: source revision, artifact hashes,
         verification results

Workflow · Release boundary

Worker input

A self-contained unit of work

The contract gives the worker exactly what is needed to create one artifact.

Contract example

artifact: catalogue/index.html
format: semantic HTML
requirements:
  required IDs: catalogue, empty-state
  stylesheet: styles/catalogue.css
  script: scripts/catalogue.js
interfaces: attached interface map
acceptance: attached behaviour criteria
output: this artifact only

Worker must not

  • Research or explore project files.
  • Write or perform code reviews.
  • Author or run tests.
  • Debug or bug-fix existing code.
  • Create unassigned artifacts or inspect a codebase.

Worker must

Use only the contract and explicitly supplied interface inputs. Generate the named artifact. If requirements conflict or are insufficient, request a contract revision instead of inferring or expanding the task.

Assembly, independent verification and acceptance belong to the orchestrator and owner.

Files & releases

Keep authority separate from output

Working Axiom documents stay outside Git. Git stores accepted Morphic releases only.

Axiom workspace · outside Git

System definition, behaviour and working change contracts.

Candidate workspace · temporary

Generated artifacts, assembly and independent verification evidence.

Git · accepted releases

Morphic build, release identity, artifact hashes and verification results.