Abstraction does not remove responsibility

A platform team ships a generator that produces contracts, prompts, adapters, and evaluation scaffolds from a specification file. Adoption spikes. Three product teams import generated cognitive units within a month. When AssessMealPracticality fails on busy Tuesday in production, the incident channel fills with familiar deflection: the model drifted, the prompt needs tuning, the generator produced bad templates. Nobody can point to the human who decided the effort ceiling, the grant that shaped inputs, or the standard the suite was supposed to enforce.

Helpful context: Software executes. Judgment does not establishes the separation. Authority is granted explains that authority is not inherited by the model or the tool that invokes it. Selection can swallow responsibility names the picker anti-pattern. This page names who still owns failure when the stack is deep, and why the Thoughtware specification rises in importance as generation rises.

Who owns failure when the stack is deep

Abstraction stacks have many layers. Household request becomes outcome and boundary in a specification. Specification becomes named cognitive units, agent strategy, deterministic gates, and memory routes through Intent Compilation. Domain libraries publish shared judgments with semantic versioning. Organisational libraries publish conduct standards. Agents compose loops with compression guards and escalation paths. Higher abstraction makes more implementation available to more people. It does not remove the need for ownership of meaning. A generator is not an owner. A library is not an owner. An agent loop is not an owner. Delegation is not absolution.

When behaviour fails, the question is what went wrong and who was responsible for the layer that went wrong. Confusing those layers produces incidents that never close because every team has a plausible excuse. In the Meal Companion stack, responsibilities remain assignable at each layer.

The library author remains responsible for published cognitive units evaluation. When AssessMealPracticality v2 ships in the meal-planning domain library, the author owns suite thresholds, substitution rules, and documented gaps. Callers trust the version because someone stood behind the evidence, not because the template looks polished. The agent owner remains responsible for loop policy: when to invoke which cognitive unit, when compression guards apply, when to escalate to human approval, when to stop unsuccessfully. The agent did not invent the judgment, but it owns the strategy that applied it. The knowledge steward remains responsible for endorsement policy: endorsed cashew allergy belongs in knowledge because a person approved it, and temporary "avoid pasta this week" must not silently become durable knowledge without approval. The household or human remains responsible for approval nodes: purchase, medical interpretation, enduring preference changes that carry consequence.

Abstraction makes the stack taller. It does not move consequence to "the model."

Specifying poorly is still owning poorly

When Intent Compilation absorbs translation work, unresolved judgment must still return to people. Specifying poorly and hoping generation will invent policy is how contested values become quiet defaults. A generated contract-review cognitive unit may be technically correct while reflecting the wrong risk posture. An evaluation suite may pass because it tests the wrong standard. The generator accelerates derivation. It cannot settle contested values or decide what good enough means for a domain the organisation has not yet clarified.

This is why making the specification executable insists on traceability. Every executable piece points back to a human-authored judgment in the specification: outcome, boundary, authority grant, memory policy, evaluation standard. When traceability breaks, debugging becomes prompt whack-a-mole. When traceability holds, a failure on busy Tuesday becomes a spec gap, a suite gap, or an authority gap with an owner.

1. 01Human-authored specificationJudgments, grants, knowledge policy, evaluation standards
2. 02Intent CompilationDerives contracts, cognitive unit, adapters, suites
3. 03Executable substrateCode, prompts, retrieval, gates
4. 04Evaluation recordEvidence that behaviour matches the spec

Generation fills the repository. Ownership stays in the specification layer.

What rises with abstraction

As substrate outgrows direct editing, three disciplines become more important, not less. The Thoughtware specification records what may exist, and without it generated files multiply faster than shared understanding. Traceability connects executable pieces to human-authored meaning, and without it teams cannot audit why a grant exists or why a suite uses a threshold. Evaluation and authority stay human-owned even when suites are generated, because passing tests against the wrong standard is worse than failing loudly.

Debugging moves toward contracts and trajectories, not prompt text alone. When conduct shifts, someone must name which layer owns the regression: cognitive unit, agent strategy, memory rule, deterministic gate, or specification gap. The Thoughtware architect owns meaning across these layers. Specialists own substrate. Generation sits between them without absorbing either role.

What this looks like in practice

Suppose an organisation publishes AskTargetedQuestion in an organisational library. Every agent must use it rather than inventing ad-hoc clarification prompts. A product team imports the library version and wraps it in agent strategy. A failure occurs: the agent asked a vague question when a material allergy ambiguity was present, and the household lost trust.

Where does responsibility live? Not with the model endpoint. The organisational library author owns the cognitive unit's conduct standard and clarification rubric. The agent owner owns the condition that triggered the call and the working state passed in. The specification author owns whether allergy ambiguity required human bridge rather than automated question. Each layer can be reviewed because each had an owner before the incident.

Compare that to a team that generated ten cognitive units from a vague PRD. Files exist. Demos pass. When production fails, nobody can say who decided the risk posture. Responsibility dissolved while the stack grew taller.

Libraries and shared reuse

When cognitive units publish to domain or organisational libraries, abstraction accelerates reuse and blurs ownership unless roles stay explicit. The library author owns version evidence and documented gaps. The importing team owns grants, authority ceilings, and composition. The architect owns placement: which judgments belong in shared libraries versus agent-private scope.

Substitution rules say which cognitive unit may replace another functionally. They do not say who owns regression when behaviour shifts. That owner must be named before promotion. Otherwise shared reuse becomes shared blame avoidance. Contract language with vendors mirrors internal traceability requirements: which capabilities serve which named judgments, which data may influence which decisions, and which logs support contestability. Without that alignment, vendor upgrades become architecture roulette.

Internal platform teams face the same test. A generator that fills repositories faster than specifications stay current creates the appearance of progress while ownership lags behind file count.

Incident review with lineage

When production fails, lineage questions come first. Which specification section authorised this grant? Which suite was supposed to catch this case class? Which library version promoted last week? Which agent strategy branch chose compression? An abstraction stack without answers becomes a blame stack. Traceability turns incidents into spec, suite, or authority updates with owners.

When generation is abundant, the scarce skill is deciding which judgments are allowed to exist, under what grants, and against which evaluation standard.

Generated implementation does not transfer responsibility to the generator.

Introduction to Thoughtware . Ch. 2

Common mistakes

Treating library import as liability transfer. Adoption of a shared cognitive units copies capability, not accountability. Callers remain responsible for grants, authority ceilings, and composition.

Evaluating generated suites without reading the spec. Generated tests can encode the wrong standard fluently. Passing is meaningless when the threshold itself was never approved.

Assuming the agent owner owns every judgment inside the loop. Agent owners own strategy. cognitive unit authors own named decisions. Humans own approval nodes. Confusing those layers produces incidents nobody can close.

What to do next

Auditing one production failure by asking which layer owned the decision that failed reveals whether traceability holds or has dissolved. Adding lineage links from executable artifacts back to specification sections makes that audit repeatable. When generation fills gaps with invented policy, requiring human sign-off on contested values before those gaps become production behaviour preserves responsibility across the abstraction stack.

See making the specification executable for the traceability discipline in full, and the Thoughtware architect for who owns meaning when generation fills the repository.

Read next: Making the specification executable.