The ThruWire Viewpoint

Models are getting capable enough that we increasingly want to let them just do the work. If they are smarter than us, who are we to tell them how to work, right? Let them solve the problem and figure out what it takes to get there.

But we can’t just hand over the work and hope for the best. We barely trust our agents today, and as models get better, watching their execution step by step becomes a weaker way to understand and govern their work.

We want agents to operate to their full potential without giving up our ability to check their work, govern what happens, and learn something along the way.

A checkpoint defines a state the work needs to reach without defining exactly how the worker gets there.

The proposition to the agent is simple: do whatever you want, however you want, as long as you can prove these X number of things happened along the way.

Between checkpoints, the agent can “cook”. At the checkpoint, it has to show its work.

That means leaving behind the right-shaped artifacts at the right time, in a form that can be validated and trusted. Put together, the checkpoints become a self-describing obstacle course for the agent.

The execution can be Claude or Codex, a custom agent, several agents working together in a software factory, a deterministic process, a human, or some combination of them.

The work should not belong to any of them.

Models will change. Agents will change. Harnesses will change. Humans will enter and leave the process. The work should survive all of them.

A trace tells us what one worker did. We care about what work now exists, which upstream work produced it, what evidence came with it, and what happened along the way.

We don’t need to own the agent loop or prescribe every tool call. We don’t need to tell the agent how to clear every obstacle.

Instead, we can define a clear contract for the work and leave the execution up to the agent.

Artifacts have stable identity. Relationships connect them to the exact upstream work used to produce them. Evidence travels with the work. Schemas and server-side validation enforce the parts of the contract we can prove directly.

The more freedom we give the agent between checkpoints, the more important those receipts become.

Not everything worth knowing about work is absolute.

An artifact can have the right shape and still be wrong. Evidence can be present without supporting the claim. An implementation can point to the right requirement without actually satisfying it.

Jev adds semantic processing to the checkpoint.

Now the work model can express gray areas without giving up the contract. We can ask to what degree evidence supports a claim, whether an implementation satisfies its requirement, or whether something extracted from a conversation really represents a requirement.

The decision can be probabilistic while the policy remains explicit.

Validation and interpretation are close cousins. Once a checkpoint can semantically validate work and reject it when necessary, it can just as easily ask what else is true about that work without making the answer part of the gate.

Some results can become policy. Some can steer the agent. Others can tell a human what deserves attention or become useful context for whatever works on the problem next.

Every checkpoint can generate new data about the work while the work is passing through.

Instead of reconstructing what happened from agent traces after the fact, we can accumulate a semantic picture of the work as it happens. As models get smarter and their execution gets harder for us to follow, we think that becomes increasingly important.

We now have frontier models capable of doing increasingly open-ended work and decision models capable of making fast semantic judgments around that work.

Neither tells us how to put the whole system together.

The checkpoints, contracts, artifacts, context, policies, feedback loops, and other deterministic connective tissue are what let System 1 and System 2 work together.

That connective tissue is where we’re building ThruWire.