Worked Examples and Falsification Tests

Universality should survive contact with ordinary work

An architecture can appear universal while every example remains conveniently large, technical, and finite. The stronger test is whether the same semantics explain both a two-minute repository change and a multi-year responsibility without forcing small work through an elaborate bureaucracy or allowing large work to fall back into an improvised model trajectory. Uniform semantics does not mean uniform materialization. A small change should create little durable structure because little structure is materially relevant. Complex or open-ended work should expose more Unknowns, Decisions, Responsibility, Authority, and Evidence because the outcome genuinely depends on them.

A semantic rename should stay small

The user asks:

Rename userPrefs to userPreferences consistently. The system may materialize only a bounded chain:

SEMANTIC LOGICIntent I1
→ Commitment C1: perform bounded repository change
→ Observation O1: resolve symbol and references
→ Decision D1: semantic rename only; no behavior change
→ Transformation W1
→ Verification W2: compiler/LSP references + tests
→ Closure

The Resource Resolver should prefer compiler or language-server semantics to a frontier model when the repository supports them. Authority is limited to the identified symbol and references; independent Observation confirms that no stale reference remains. There is no reason to invent a project plan, permanent coding team, or broad architecture review. The architecture fails this example in either direction: if it spends expensive cognition manufacturing unnecessary ceremony, or if it accepts the executor's done without observing the resulting repository state.

A production capability requires semantic work before implementation

“Build a production-grade notification capability” is too broad for immediate coding and still concrete enough to accept as a Commitment.

SEMANTIC LOGICCommitment C1:
  design, implement, and verify the capability
  under bounded software-development Authority

Outcomes:
  O1 notification commitment semantics
  O2 user preference management
  O3 asynchronous delivery
  O4 user-visible state
  O5 reliability and recovery
  O6 observability and Acceptance

The initial Work may expose Unknowns about event ownership and provider acknowledgement, then Decisions about the point of commitment, retry and idempotency, and the user-visible lifecycle. Research Resources inspect authoritative provider documentation and existing integration behavior; the software DomainModel records services, contracts, schemas, transaction boundaries, and failure semantics. Several design alternatives can coexist without becoming current reality:

SEMANTIC LOGICS1: direct provider call with local persistence
S2: transactional outbox with dispatcher

Each alternative carries Assumptions, failure modes, and Obligations. The authorized architecture owner accepts one Decision after reviewing Evidence and trade-offs. The selected alternative enters ACTUAL_ACCEPTED; the rejected one remains historically interpretable rather than disappearing from a rewritten plan. The accepted target can then be compiled into semantic changes, impact, bounded WorkUnits, and a Verification matrix. A leaf may be precise enough for a smaller coding Resource:

YAMLkind: ImplementationUnit
goal: Atomically claim one pending notification
scope:
  allowed:
    - modules/notifications/**
  forbidden:
    - auth/**
preconditions:
  - state machine approved
  - repository contract observed
postconditions:
  - at most one concurrent worker obtains claim
  - claimed record becomes PROCESSING
verification:
  - integration scenario
  - concurrent claim scenario

After Execution, the repository, compiler, tests, CI, and runtime are observed independently. Evidence is mapped to Obligations, and the executor remains unable to close the parent capability. If implementation discovers that transaction ownership differs from the accepted model, it submits a Contradiction and impact proposal; only the dependent region becomes stale or requires recompilation. This is materially different from asking one coding agent to plan, implement, adapt its interpretation, run tests, and decide that the feature is finished.

A travel responsibility remains mostly dormant

The user asks:

Monitor my trip and help if something goes wrong. This creates a Maintenance Commitment, not a recurring prompt.

SEMANTIC LOGICmaintained condition:
  trip remains viable under user constraints

may:
  observe authoritative travel state
  research alternatives
  prepare recommendations

may not:
  rebook without approval
  exceed budget threshold

Most of the time no model is running. An Observer watches authoritative flight state, and a material cancellation activates a finite Horizon. The UserModelSlice includes only information relevant to this Responsibility: current itinerary and calendar, travel preferences and recent drift, budget, location, loyalty status, standing Authority, and selected prior Episodes. Research may produce two viable alternatives:

SEMANTIC LOGICA: earlier arrival, higher price, one connection
B: later arrival, lower price, direct
recommendation and Evidence
budget impact
rebooking deadline

A HumanDecision supplies the missing Authority. An execution Resource performs the rebooking; a separate Observation confirms the new reservation; the Horizon closes and the parent Commitment returns to watching. A conversation summary plus a daily model prompt can imitate this experience for a while. It cannot carry the same semantics of standing Responsibility, dormant observation, scoped Authority, and event-triggered activation.

Open research should be allowed to remain uncertain

The user asks whether a new rehabilitation technology is commercially viable. The correct initial state is incomplete:

SEMANTIC LOGICUnknowns:
  market definition
  clinical Evidence
  regulatory path
  buyer and payer
  competing alternatives
  economics

Hypotheses:
  H1 technology produces meaningful clinical advantage
  H2 target providers can adopt within workflow constraints
  H3 reimbursement or buyer economics support deployment

Independent Research Resources receive different Source scopes. Evidence preserves provenance and Source Authority; Contradictions remain visible rather than being averaged into a smooth narrative. A synthesis Resource may propose an Inference with confidence, supporting and opposing Evidence, unresolved uncertainty, and sensitivity to Assumptions. Metacognitive control decides whether another search, expert inquiry, or experiment has enough expected information value to justify its cost. A valid result may remain conditional:

SEMANTIC LOGICcommercially promising under Assumptions A and B;
regulatory timeline remains material Unknown U7;
confidence medium;
next action: targeted expert inquiry and pilot economics

The system has failed if fluency turns uncertain estimates into Facts, or if the Research stops only because the current narrative feels complete.

Organizational work crosses the decomposition tree

“Prepare the company for an external audit” creates one parent Commitment whose Work spans finance, legal, security, operations, documents, and people. Responsibilities may be assigned to an accountant, security lead, document Resource, Research model, external counsel, control verifier, and human Acceptance authority. The Responsibility Graph necessarily crosses the Work decomposition. One human may hold Decision authority over several branches; one Evidence Artifact may satisfy multiple Obligations; one missing document may block several descendants. Delegates can fulfill their own assignments without gaining the right to declare the company audit-ready. Parent Closure requires coverage, fresh Evidence, accepted exceptions, approvals, and the absence of blocking Contradictions. A coordinator checklist and departmental done reports are insufficient because local completion does not prove the parent outcome.

Incidents change budgets, not laws

A critical service fails under time pressure. The architecture should respond faster without abandoning the semantics that make recovery trustworthy.

SEMANTIC LOGICIncident Horizon activated
→ authoritative Observations collected
→ blast radius and current Risk assessed
→ pre-authorized reversible mitigations available
→ consequential changes remain purpose-bound
→ Evidence and effect history recorded

A known rollback may execute immediately under standing Authority. A novel and irreversible data migration may still require stronger review. Intended state and observed history remain separate; ambiguous effects still require reconciliation; emergency action does not grant ambient permission. After stabilization, the Horizon continues through diagnosis, remediation, Verification, and LearningCandidates. The architecture has regressed if urgency collapses Responsibility, Authority, and Evidence into one operator's Context.

Creative work needs exploration without fake precision

The user asks for a strong brand concept. The desired state is initially under-specified, and exploration is legitimate Work. The system may materialize audience and positioning Unknowns, creative constraints, several concept alternatives, critique rounds, user aesthetic Decisions, an accepted direction, rationale, Artifacts, and Acceptance. The architecture should not pretend that every aesthetic property can be objectively verified before exploration begins. Closure can still require coverage of the brief, consistency among selected Artifacts, human Acceptance, and resolution of material Contradictions. The Materiality Boundary keeps every sketch out of durable Work IR while preserving the alternatives and Decisions that genuinely shaped the result. Overformalizing creative work is a failure. So is hiding all creative direction inside one model's private taste.

Continuous software health uses successive Horizons

“Keep this production service healthy” is a Maintenance Commitment with ongoing Observation and successive finite Horizons:

One successful health check cannot close the Commitment. The system remains quiescent while state is acceptable and activates cognition only when thresholds, events, stale Evidence, or review conditions require it. This case is the practical no-LLM test: responsibility remains active and observable while inference is absent.

The domain changes; the laws do not

Across these examples, the same invariants remain stable:

1. Intent does not automatically create Commitment.
2. Commitment does not create unlimited Authority.
3. Non-executable Work is refined rather than rejected.
4. Unknowns and Decisions remain explicit.
5. Responsibility is assigned independently of Decomposition.
6. Context is compiled for the Responsibility.
7. Models and humans propose changes; admission creates canonical revisions.
8. External effects are independently observed.
9. Results do not imply satisfaction.
10. Closure follows Obligations, Evidence, Acceptance, and Policy.
11. Maintenance Work advances through Horizons rather than permanent done.
12. Learning cannot expand Authority. A universal architecture earns the name by preserving these laws while allowing domain-specific models, compilers, Capabilities, and Closure rules to change.

Twelve tests expose architectural drift

The empirical program should attack the strongest claims

The architecture should be compared with a strong current harness using the same models, tools, and environment. Seven experiments cover the central failure modes.

The proposal can fail

The practical case weakens if controlled implementations show that typed semantics add substantial cost without reducing rework or false completion; model-authored plans recover equally well under changed premises; local invalidation offers no advantage over global replanning; DelegationContracts do not improve outcomes; Assurance fails to catch false executor success; model-independent state adds no long-horizon continuity; or a stronger model alone dominates the architectural gains at comparable cost and Risk. These are not ceremonial caveats. A serious research program must permit those results.

Success has an operational shape

The architecture succeeds if it preserves valid Work under change, exposes unresolved uncertainty before execution, allocates expensive cognition selectively, delegates without losing accountability, constrains Authority across long trajectories, detects false completion, explains actions from semantic state, remains useful while cognition is dormant, and improves Procedures without becoming self-authorizing. The practical standard is not whether every activity can be drawn as a graph. It is whether the system makes delegated work more correct, inspectable, recoverable, governable, and economical than a state-of-the-art trajectory-centered harness using the same models.