Dimensional Frame Harness  ·  a builder's showcase

I study how coordination fails. Agents fail the same way.

A short walk through how I got here, and then the harness itself, running on real code. It reads an agent's whole run and blocks the harm that no single step is. Here is the road to it, the thing running, and the one lesson worth taking away.

01 · where this starts

How coordination fails.

What we tested

  • How coordination behaves under real pressure, across many different kinds of organizations.

What we learned

  • A healthy coordination system holds together under tension, like a tensegrity: when one part gives way, the load runs through the whole, so a failure propagates rather than staying local.
  • The failures are not random. The same shapes recur: a handoff drops, a warning goes unengaged, a decision rests on ground that already shifted.
  • Because they recur, they can be named and written down. That is where all of this starts.
A luminous tensegrity structure with glowing cyan struts held in balance by tension; one strut has snapped and glows red, and the surrounding cables buckle as the load redistributes through the whole.

a healthy coordination structure under tension: one strut fails and the whole redistributes

02 · what I built

I wrote the patterns down, and made them run.

What we tested

  • Whether those failure-patterns could be made enforceable, not just described.

What we learned

  • They can: a suite of five kinds of integrity on a floor of precision, meaning, structure, data, evaluation, and time.
  • Made executable, so a machine holds a live system to them, not just a person reading a document.
  • The harness is the layer on top that puts them to work on a running agent.
A faceted solid whose five colored bands are the five kinds of integrity: meaning at the crown in red, then structural in orange, data in gold, evaluation in green, and temporal in blue at the base, held between a luminous Precision floor (PFDS) and a Dimensional Frame Harness ceiling (Action Integrity).

03 · the recognition

An agent is a coordination system too.

What we tested

  • Whether the coordination-failure patterns I found in organizations also show up in agentic AI.

What we learned

  • They do. An agent learned to coordinate from human data, so it fails the way we do, only faster.
  • The same shapes, at machine speed and at scale, with far less room to catch itself.
  • Meeting that speed and scale: a forthcoming layer, the Coordination Nervous System, shipping as part of the Dimensional Frame Harness release.
A single lone amber coordination unit on the left, dwarfed by the same unit multiplied into a vast swarm of identical cyan copies streaming in at high speed from the right, dense and overwhelming.

one unit on its own, then the same shape as a swarm, at machine speed and scale

04 · the failure to watch

Every step passes. The whole is the harm.

What we tested

  • Whether checking each action on its own catches the harm.

What we learned

  • It does not. The harm is only in how the actions combine.
  • You have to read the whole run, which is exactly what the harness reads and a per-action gate misses.
A field of calm blue glowing points, each one benign, whose connecting lines together trace the unmistakable red silhouette of a predatory creature, visible only when the points are seen as a whole.

each point is benign; only the whole shows the shape of the harm

05 · watch it run

So I built a harness that reads the whole run.

Here it is, running on real code. The run builds on the left and the monitor evaluates it on the right. The one thing to watch for: the send that carries a sensitive record out of the system, which every step approved.

idletip: click any phase on the left to jump back
the run
phases · click to revisit
    reference-monitor.mjs · footprint ledgeridle

    Press Run the agent to start. The monitor evaluates each action as the agent takes it, and logs one record for every action whether or not a rule fires.

    06 · what testing taught

    Tested against real models, not asserted.

    What we tested

    • This against real models from more than one provider.

    What we learned

    • When the composed-harmful path is the expedient one, the models take it. Different models, the same move.
    • A per-action check clears every step, because no single action is wrong on its own.
    • The harm only becomes visible when the whole run is read together.
    • It is early and tested in the open; the read sharpens with every real run.
    Several independent glowing cyan trails, each starting from a different node, all converging onto one shared path through green ring checkpoints and ending together at a single bright red danger node.

    independent models, given the chance, converge on the same harmful route

    07 · what it will not fake

    Where a re-route slips past, it says so.

    What we tested

    • A re-route through a surface no rule was written for.

    What we learned

    • No rule catches it, and the harness does not pretend to.
    • It records the action and sends it to review; a log that writes only when a rule fires is blind to exactly that case.
    • Nothing leaves the system silently.
    A glowing cyan grid floor with tall luminous pillars; a small object slips through the gap between two pillars untouched, but presses a glowing amber footprint into the grid floor where it passed.

    what slips past the rules is not caught, it is traced

    08 · the lesson

    Read the run, not just the step.

    Agent safety is a coordination problem. Do not only gate actions one at a time. Read the run as a whole, and hold each action to what the agent said it was doing. That is the mistake you now do not have to make.

    The standards behind it

    Integrity Suite The Coordination Structural Integrity Suite: the standards this harness runs, and how to use them. Start here. Run it on your own organization An AI prompt launcher. Copy a prompt into any AI assistant and it walks your organization through the suite. The standards in full, on GitHub Ten standards for how coordination holds and fails under pressure, with the reasoning behind each. Polymathie The studio where the harness and the standards are built.
    frame read · held

    The demo above is the real deterministic monitor from the DFH prototype, running in your browser, on a scenario modeled on the shape of the July 2026 Hugging Face incident: an agent moving sensitive material out, then re-routing through a channel no rule covers. The verdicts are the code's own output. It is not a claim that this harness would have stopped that breach.

    How the harness reads an agent's operating stance from its own language is a separate method, held. What runs here is the deterministic layer that works today: it blocks what the standards cover, and surfaces what they do not.