---
title: "The Contract · concept · Agentic Atlas"
description: "The Contract: the agreement on an artifact's shape and use whenever one component hands it to another."
canonical: "https://agentic-atlas.dev/nodes/contract-documentation"
last-updated: "2026-09-23"
---

1. [Agentic Atlas](https://agentic-atlas.dev/)
2. [Patterns in the Agentic Atlas](https://agentic-atlas.dev/atlas)
3. [Foundations](https://agentic-atlas.dev/nodes/foundations)
4. The Contract

Seen working in [The Shared Shape](https://agentic-atlas.dev/nodes/shared-shape).

1. concept
   # The Contract
   **How do you define what two components exchange?**
   Treat every handoff in an agent system as a contract, documented as heavily as its conditions demand.
   Hook
   the agreement on an artifact's shape and use whenever one component hands it to another
   Laws & fences
   - Per-handoff details like provenance cannot live in the design-time agreement, so each handoff carries them when its conditions require.
   - Four handoff conditions each scale exactly one contract part, so each handoff's checklist can be recomputed from them.
   - The sender must deliver either the payload itself or a pointer to it.
   - A handoff without a contract cannot be checked, so its task cannot safely be dispatched again.
   - A contract is worth having only while it is kept in sync with the behavior it describes.
   - The contract explains how a handoff works, not why anyone created the handoff.
   When to reach
   - Reach for this when each handoff in your system gets its own improvised format and rigor.
   - Reach for this when an agent receives unstructured data and must guess what it is and how to use it.
   Provenance
   [contract-documentation/definition](https://agentic-atlas.dev/nodes/contract-documentation#definition) · v1.0.11
   Addresses
   atlas_cards contract-documentation
2. [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
3. [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone)
4. [Foundations](https://agentic-atlas.dev/nodes/foundations)
5. [Effect Discipline](https://agentic-atlas.dev/nodes/effect-discipline)
6. [Verification Asymmetry](https://agentic-atlas.dev/nodes/verification-asymmetry)
7. [Baseline Skill](https://agentic-atlas.dev/nodes/baseline-skill)
8. [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
9. [The Shared Shape](https://agentic-atlas.dev/nodes/shared-shape)
10. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
11. [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
12. [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
13. field notes
    - “validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied”
    - “episodic skills with persisted, context-specific behavior — incl. the *free idempotent setup* optimization”
    - “the travelling declared-shape contract specialization”
    - “accumulated memory, a **separate concern from config**”
    - “one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung”

Heavy AgentThe Shared Shape +6 more unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links contract-documentation

On this plate

[definition](https://agentic-atlas.dev/nodes/contract-documentation#definition) [why-it-matters](https://agentic-atlas.dev/nodes/contract-documentation#why-it-matters) [model-and-claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) [scope-and-boundaries](https://agentic-atlas.dev/nodes/contract-documentation#scope-and-boundaries) [implications-the-consequence-map-and-tradeoff](https://agentic-atlas.dev/nodes/contract-documentation#implications-the-consequence-map-and-tradeoff) [evidence-the-derived-readings](https://agentic-atlas.dev/nodes/contract-documentation#evidence-the-derived-readings) [relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) [lineage](https://agentic-atlas.dev/nodes/contract-documentation#lineage) [examples](https://agentic-atlas.dev/nodes/contract-documentation#examples) [open-questions-todo](https://agentic-atlas.dev/nodes/contract-documentation#open-questions-todo) [relationships-ledger](https://agentic-atlas.dev/nodes/contract-documentation#relationships-ledger)

Every section is addressable on its own. Read only the ground you need.

## Definition

[Permalink to Definition section](https://agentic-atlas.dev/nodes/contract-documentation#definition)

**Treat every crossing as the same [primitive](https://agentic-atlas.dev/glossary/primitive): a contract** — a two-tier agreement between sender and receiver, documented in proportion to what the seam's conditions demand. The primitive *suggests structures, never mandates fields*: it supplies a definition, four dials that read any seam's conditions, and the obligations each dial turns on. What the contract *says* is always seam-specific.

## Why it matters

[Permalink to Why it matters section](https://agentic-atlas.dev/nodes/contract-documentation#why-it-matters)

In traditional programming you document function parameters, type signatures, invariants. That discipline gets *lost* the moment you move into agentic systems: data gets passed around unstructured and you hope the LLM figures it out. Hand a probabilistic reader unstructured data and it burns reasoning cycles on "what am I seeing, how do I use this" — or worse, guesses confidently and proceeds.

The deeper failure is fragmentation. An agentic system is riddled with handoffs — [dispatch](https://agentic-atlas.dev/glossary/dispatch), return, [config](https://agentic-atlas.dev/glossary/config) file, [state](https://agentic-atlas.dev/glossary/state) artifact, packed [envelope](https://agentic-atlas.dev/glossary/context-envelope), [workspace](https://agentic-atlas.dev/glossary/workspace) file, human [gate](https://agentic-atlas.dev/glossary/gate), session handoff — and each tends to get treated as its own ad-hoc problem with its own ad-hoc rigor, when they are all crossings of the same seam.

## Model and claims

[Permalink to Model and claims section](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims)

### Anatomy — two tiers, non-normative

- **Tier 1 — the standing agreement.** The shared expectation of shape and how-to-consume, authored at design time, holding across all crossings of the seam. USB analogy: the published spec both sides implement before any device plugs in. This *is* the contract's definition — a handshake between stages, whatever the party types (LLM↔LLM, LLM↔deterministic, deterministic↔LLM, human on either end).
- **Tier 2 — per-instance obligations.** What each individual crossing must carry: provenance, freshness, the SHA+datetime stamp. USB analogy: enumeration — every device still self-declares its descriptors at plug-in. Tier 1 *obligates* tier 2 but cannot contain it: stamps are minted per crossing.

**Posture: suggest structures, never mandate fields.** There is no universal field list at this altitude; the two-tier *structure* is the universal part, and seam-specific content fills it. The primitive stamps no standard on the strategies that wield it.

### The census — one primitive, many seams, four dials

The seams of an agentic system — dispatch, return, config, state artifact, envelope, workspace handoff, human gate, session handoff — are all this one primitive under different conditions. Four dials read any seam's conditions; each dial scales **exactly one** piece of contract machinery, which is what makes the derived checklists mechanical (recomputable, so they can't drift):

| Dial | Scales | Machinery it turns on |
| --- | --- | --- |
| **Cost-of-asking** (free → expensive → impossible; continuous) | completeness | tier-2 assumptions/provenance — everything in the artifact |
| **Write→read gap** (zero → long) | freshness | tier-2 stamps, supersession rules |
| **Receiver type** (LLM / deterministic code / human) | precision | tier-1 strictness — schema exactness |
| **Sender type** (LLM / deterministic code / human) | verification weight | assertion role → [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone), *validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied* |

There is no topology or time dial: "the sender is gone by read time" was always the back-channel variable, already priced as **cost-of-asking** by the envelope's lifetime-overlap spectrum (full overlap = free; partial = expensive, re-dispatch; zero = impossible). *Causes* of a dead back-channel (sender gone vs. one-way by design) are explanation, not columns — author to the channel as designed.

**Reading verification weight.** The dial reads **two** things: sender type supplies *how likely* a bad crossing is; what the receiver will *do* with the artifact supplies *how much a bad one costs*, with [Effect Discipline](https://agentic-atlas.dev/nodes/effect-discipline)'s licensing classes (pure / idempotent / isolated; reversible-at-a-cost → irreversible) as the coarse guide — the irreversible end hands off to the human gate. **No fifth dial**: the fine structure (rerunability, time sensitivity, re-run cost, blast radius) is designer judgment, deliberately unpriced — the same posture as cost-of-asking, which also collapses many factors into one qualitative read. When the resulting weight is high enough, the assertion *reifies into a checker stage* — see *validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied*.

**Mid-spectrum rigor relaxation is legitimate.** Where re-dispatch exists, a lighter contract is *lazy contract negotiation priced at re-dispatch cost*, not sloppiness — licensed when catching a starved crossing downstream is cheaper than fully specifying it upfront.

### Delivery — the sender's obligation; there is no pull

The sender pushes either the **payload** or a **[pointer](https://agentic-atlas.dev/glossary/pointer)** to it; "pull" is push-of-a-pointer seen from the wrong end. Three consequences:

1. **Pointer resolvability at read time is a tier-2 obligation**: the path exists, access is granted, and a one-line "what this is" annotation rides with it.
2. **The pointer chain bottoms out** in a harness-guaranteed delivery surface, whose selection is the bootstrap seam's job (*episodic skills with persisted, context-specific behavior — incl. the *free idempotent setup* optimization*) — a cross-reference, not an anatomy element.
3. **No delivery channel → the seam does not exist yet.** Name the precondition before contracting the crossing.

**Return-by-reference's one home is here** — it is the pointer variant of delivery. The dispatch's packing anatomy ([LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch) → *Anatomy of a dispatch*) and the workspace channel below both point back to this clause.

### The workspace seam — a census entry worth naming

Any workspace location one [actor](https://agentic-atlas.dev/glossary/actor) writes and another reads is a seam whose **write→read gap is nonzero** — the dials already price it, and no dispatch relationship is required. The envelope's zero-lifetime-overlap case is this same seam at the impossible end of cost-of-asking. Two rules land here:

- **Writer-owns-the-boundary** — one writer per location, or a designed seam (*accumulated memory, a **separate concern from config***'s rule, generalized) — a dial-conditioned obligation, not an anatomy element.
- The *channel* itself — actors sharing a filesystem — is dispatch-side Structure ([LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)); this node owns only the contract on what crosses it.

## Scope and boundaries

[Permalink to Scope and boundaries section](https://agentic-atlas.dev/nodes/contract-documentation#scope-and-boundaries)

This is a **primitive**, not a strategy: it says *how* a seam works, not *why* you created one. The seam-creating moves — dispatching a [subagent](https://agentic-atlas.dev/glossary/subagent), deferring context, persisting state, packing an envelope — supply the motive; each pays off only when its seam is contracted.

### Admission — the achievable-without test

Content belongs in a seam's contract only if the seam **cannot function without it**; everything else is admitted only as a **dial-conditioned obligation** — appearing as conditions harden, invisible otherwise. Applied:

- The **shared expectation** (tier 1) survives — without it there is no contract at all.
- Stamps, completeness, schema exactness, pointer rules are all **conditional** — turned on by the four dials.
- **Goal-source fails the test** and stays envelope-side (*the travelling declared-shape contract specialization*): a seam functions without knowing whose goal minted the payload.

The primitive's architecture follows: **definition + four dials + the obligations each dial turns on** — descriptive, never normative.

## Implications — the consequence map and tradeoff

[Permalink to Implications — the consequence map and tradeoff section](https://agentic-atlas.dev/nodes/contract-documentation#implications-the-consequence-map-and-tradeoff)

Authoring effort and **sync discipline**: a contract drifts under the behavior it describes, and tier 1 is only worth having while it stays true — you pay in specification rigor per seam and keep paying to keep it honest. The non-normative posture has its own price: the primitive hands you dials, not a finished checklist — deriving each seam's checklist is designer work (deliberately, so derived checklists stay recomputable rather than drifting copies). You buy back preprocessing, composability, and the very possibility of verification: an uncontracted seam cannot be checked, so it cannot be safely re-dispatched.

## Evidence — the derived readings

[Permalink to Evidence — the derived readings section](https://agentic-atlas.dev/nodes/contract-documentation#evidence-the-derived-readings)

A non-normative primitive is evidenced by what can be **recomputed from it**, and by what its admission test refuses.

- **One derivation on record.** The dispatch's *packing checklist* lives in [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch) → *Anatomy of a dispatch* as an explicitly derived reading of the four dials *(2026-07-05)* — a checklist recomputed from the dials rather than a copy kept in sync.
- **Two refusals on record.** Goal-source failed the achievable-without test and stays envelope-side; the topology/time dial was collapsed into cost-of-asking once the envelope's lifetime-overlap spectrum was found to price it already.
- **What would revise it.** A seam whose machinery no dial scales — one needing a fifth column rather than designer judgment — breaks the census's claim that these are one primitive under four conditions.

## Relationships

[Permalink to Relationships section](https://agentic-atlas.dev/nodes/contract-documentation#relationships)

- **Substrate, like the dispatch.** Sits in Foundations beside [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch) — the tree's two primitives: the dispatch is the actor boundary, the contract is the seam. Strategies *wield* both rather than apply them.
- **Generalized by [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone)** (contract ↔ verification ↔ re-dispatch): the contract is the possibility condition of checking; the sender-type dial's verification weight hands off there and to *validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied*.
- **The return contract ties contract → heavy agent.** A heavy agent ([Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)) only pays off if what it hands back is itself distilled and structured; otherwise the context cost is relocated to the orchestrator, not eliminated.
- **[Effect Discipline](https://agentic-atlas.dev/nodes/effect-discipline)** supplies the licensing classes that the verification-weight dial's cost read is coarse-guided by.
- ***episodic skills with persisted, context-specific behavior — incl. the *free idempotent setup* optimization*** owns the bottom of the pointer chain — the harness-guaranteed delivery surface.
- **The envelope** (*the travelling declared-shape contract specialization*) is the census's far-end seam: its lifetime-overlap spectrum is what priced the old time leg into cost-of-asking, and goal-source lives there, not here.

## Lineage

[Permalink to Lineage section](https://agentic-atlas.dev/nodes/contract-documentation#lineage)

Design by Contract (Meyer), and interface documentation as specification (Parnas, "On the Criteria To Be Used in Decomposing Systems into Modules", 1972): the documented parameter, type signature, and invariant, carried across a seam where nothing enforces them.

## Examples

[Permalink to Examples section](https://agentic-atlas.dev/nodes/contract-documentation#examples)

- **[The Shared Shape](https://agentic-atlas.dev/nodes/shared-shape)** — a caller and a research step import one seam-owned module containing both request and return shapes. The agreement changes once; both sides encounter the same change.
- ***one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung*** (drafting) — the review ladder's data-package seam is contracted shared-shape style inside rung (c): the ladder has no standalone contract rung, because the contract is how the seam is built.

## Open questions / TODO

[Permalink to Open questions / TODO section](https://agentic-atlas.dev/nodes/contract-documentation#open-questions-todo)

- **Cleanup/lifecycle of workspace handoff artifacts** — who deletes a handoff artifact, and when? The contract dials price freshness and lifecycle but do not yet assign deletion authority for this artifact class.

The relationships ledger

Evidence-bearing references

## Relationships

Every connection keeps the section where it was found. The map above orients; this ledger carries the evidence.

### Outbound references 19

1. in-slice · occurrence 1
   [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone)
   how contracts, cheap checks, and safe discards together make agent handoffs safe
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 1
2. undisclosed · occurrence 2
   Undisclosed relationship
   validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 2
3. in-slice · occurrence 3
   [Effect Discipline](https://agentic-atlas.dev/nodes/effect-discipline)
   which recovery moves an agent run's side effects still allow: discard, retry, or compensate
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 3
4. undisclosed · occurrence 4
   Undisclosed relationship
   validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 4
5. undisclosed · occurrence 5
   Undisclosed relationship
   episodic skills with persisted, context-specific behavior — incl. the *free idempotent setup* optimization
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 5
6. in-slice · occurrence 6
   [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
   one LLM execution starting another, whether the parent waits, joins later, or never joins
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 6
7. undisclosed · occurrence 7
   Undisclosed relationship
   accumulated memory, a **separate concern from config**
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 7
8. in-slice · occurrence 8
   [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
   one LLM execution starting another, whether the parent waits, joins later, or never joins
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/contract-documentation#model-and-claims) · occurrence 8
9. undisclosed · occurrence 1
   Undisclosed relationship
   the travelling declared-shape contract specialization
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/contract-documentation#scope-and-boundaries) · occurrence 1
10. in-slice · occurrence 1
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
    one LLM execution starting another, whether the parent waits, joins later, or never joins
    Evidence: [Evidence](https://agentic-atlas.dev/nodes/contract-documentation#evidence-the-derived-readings) · occurrence 1
11. in-slice · occurrence 1
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
    one LLM execution starting another, whether the parent waits, joins later, or never joins
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 1
12. in-slice · occurrence 2
    [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone)
    how contracts, cheap checks, and safe discards together make agent handoffs safe
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 2
13. undisclosed · occurrence 3
    Undisclosed relationship
    validate at the return seam; re-dispatch over repair; bounded autonomy — the contract keystone, applied
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 3
14. in-slice · occurrence 4
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
    subagents that carry heavy baked-in instructions the orchestrator never loads
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 4
15. in-slice · occurrence 5
    [Effect Discipline](https://agentic-atlas.dev/nodes/effect-discipline)
    which recovery moves an agent run's side effects still allow: discard, retry, or compensate
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 5
16. undisclosed · occurrence 6
    Undisclosed relationship
    episodic skills with persisted, context-specific behavior — incl. the *free idempotent setup* optimization
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 6
17. undisclosed · occurrence 7
    Undisclosed relationship
    the travelling declared-shape contract specialization
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/contract-documentation#relationships) · occurrence 7
18. in-slice · occurrence 1
    [The Shared Shape](https://agentic-atlas.dev/nodes/shared-shape)
    two steps import one shared file defining what they send and return
    Evidence: [Examples](https://agentic-atlas.dev/nodes/contract-documentation#examples) · occurrence 1
19. undisclosed · occurrence 2
    Undisclosed relationship
    one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung
    Evidence: [Examples](https://agentic-atlas.dev/nodes/contract-documentation#examples) · occurrence 2

### Inbound references 16

1. in-slice · occurrence 1
   [Baseline Skill](https://agentic-atlas.dev/nodes/baseline-skill#definition)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Definition](https://agentic-atlas.dev/nodes/baseline-skill#definition) · occurrence 1
2. in-slice · occurrence 2
   [Baseline Skill](https://agentic-atlas.dev/nodes/baseline-skill#relationships)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/baseline-skill#relationships) · occurrence 2
3. in-slice · occurrence 4
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#relationships)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-economy#relationships) · occurrence 4
4. in-slice · occurrence 1
   [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent#verification-what-this-example-deliberately-leaves-out)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Verification](https://agentic-atlas.dev/nodes/docs-expert-agent#verification-what-this-example-deliberately-leaves-out) · occurrence 1
5. in-slice · occurrence 6
   [Effect Discipline](https://agentic-atlas.dev/nodes/effect-discipline#relationships)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/effect-discipline#relationships) · occurrence 6
6. in-slice · occurrence 2
   [Foundations](https://agentic-atlas.dev/nodes/foundations#definition)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Definition](https://agentic-atlas.dev/nodes/foundations#definition) · occurrence 2
7. in-slice · occurrence 5
   [Foundations](https://agentic-atlas.dev/nodes/foundations#model-and-claims)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/foundations#model-and-claims) · occurrence 5
8. in-slice · occurrence 2
   [Foundations](https://agentic-atlas.dev/nodes/foundations#evidence-the-test-s-track-record)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Evidence](https://agentic-atlas.dev/nodes/foundations#evidence-the-test-s-track-record) · occurrence 2
9. in-slice · occurrence 2
   [Foundations](https://agentic-atlas.dev/nodes/foundations#relationships)
   the agreement on an artifact's shape and use whenever one component hands it to another
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/foundations#relationships) · occurrence 2
10. in-slice · occurrence 1
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch#relationships)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/llm-dispatch#relationships) · occurrence 1
11. in-slice · occurrence 5
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#relationships)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 5
12. in-slice · occurrence 1
    [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone#scope-and-boundaries-where-the-argument-stops)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/the-contract-keystone#scope-and-boundaries-where-the-argument-stops) · occurrence 1
13. in-slice · occurrence 1
    [The Contract Keystone](https://agentic-atlas.dev/nodes/the-contract-keystone#relationships)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/the-contract-keystone#relationships) · occurrence 1
14. in-slice · occurrence 1
    [Verification Asymmetry](https://agentic-atlas.dev/nodes/verification-asymmetry#model-and-claims)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Model and claims](https://agentic-atlas.dev/nodes/verification-asymmetry#model-and-claims) · occurrence 1
15. in-slice · occurrence 4
    [Verification Asymmetry](https://agentic-atlas.dev/nodes/verification-asymmetry#model-and-claims)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Model and claims](https://agentic-atlas.dev/nodes/verification-asymmetry#model-and-claims) · occurrence 4
16. in-slice · occurrence 2
    [Verification Asymmetry](https://agentic-atlas.dev/nodes/verification-asymmetry#relationships)
    the agreement on an artifact's shape and use whenever one component hands it to another
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/verification-asymmetry#relationships) · occurrence 2

[↑ back to the top](https://agentic-atlas.dev/nodes/contract-documentation#content) [← the survey](https://agentic-atlas.dev/atlas)

Node contract-documentation · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61