Agent frameworks (LangGraph, CrewAI, AutoGen) coordinate agents with agents. They pass state between machines. They break at the moment a human needs to step in. When a domain expert sees the analysis drift, the options are restart the run with new instructions, or cross your fingers.

Team tools (Claude Projects, ChatGPT Teams, Notion AI) coordinate humans with humans. They embed AI inside each person's session, which is useful in the session and gone after it. Nothing persists in a form the next participant can inspect.

Enterprise agent platforms (Bedrock, Vertex, OpenAI Frontier) sit agents underneath humans. They handle deployment, permissions, and governance. They do not handle humans and agents building something together. They handle humans deploying agents at something.

The missing layer is where humans and agents coordinate with each other. Both sides authoring. Both sides executing. Both sides reading and extending the same structured work.

A harness is everything you wrap around a model to get it to do what you want. Tools, skills, memory files, MCP servers, configuration, the loops that run until a task completes. Every AI system runs inside a harness. ThruWire is a harness. What makes it different is that it is extensible by multiple participants, including participants who are not human. Humans and agents build it out together, block by block, using the same primitives.

In a traditional harness, the structure of the work is ephemeral. It gets narrated in prompts, held briefly in a scratchpad, carried in the model's hidden state for the length of a loop, and then lost when the session ends. The structure was real for a moment. It is unreachable now. This works when one person is steering one loop toward one task. It breaks the moment a second participant needs to contribute. There is nothing for them to contribute to, because the structure lived inside a loop that closed.

In ThruWire, the structure is externalized. Every dependency is declared. Every boundary is explicit. Every artifact has a contract. The harness is readable by the person who built it. By a colleague who opens the project tomorrow. By an agent that picks up a branch and runs it. You cannot coordinate across participants on a structure only one participant can see.

A product manager is building a PRD. The customer research, the technical constraints, the competitive context, and the spec are separate blocks in the same graph. Engineering pushes back on scope. The PM updates the constraints block. The spec re-runs. The timeline re-runs. The stakeholder summary re-runs. Engineering does not get a briefing doc. They depend directly on the same customer research block that produced the PRD. When the research updates, every discipline downstream updates from the same source.

A founder is refining positioning over weeks. An agent runs updated competitive research overnight. The founder opens the result in the morning, reads the intermediate artifacts, sees that one competitor was mischaracterized, updates the competitive block with a specific constraint, and re-runs just that block plus its downstream dependents. The hiring pitch updates. The product roadmap updates. The board narrative updates. One edit, three artifacts, no manual reconciliation.

A researcher is working a problem over months. The methodology is its own block. Each line of inquiry is a branch that depends on it. Agents explore the branches in parallel. When the researcher refines the methodology, every analysis downstream of it re-runs against the new methodology automatically. Nothing is re-prompted. The propagation is structural.

This is what most knowledge work is becoming. The lawyer drafting across jurisdictions. The clinician coordinating a care plan. The analyst threading quarterly research. The operator running a rollout. All of them need a structure that holds the work together as it grows past what a single session can hold.

Humans and agents in ThruWire are teammates in the way a senior engineer and a new hire are teammates, or a strategist and a junior analyst. They are not cognitively equivalent. They have different strengths, different failure modes, and different things their collaborators need to check before trusting their output. What makes them teammates is that they work on the same thing, in the same shape, with the same primitives, and each one's contribution is legible to the other.

In ThruWire, the shape of the work is a graph. A block is a unit of authored structure. It declares a goal, a context, the artifacts it depends on, the isolation boundaries that constrain what it can see, and the steps it will take. Building a block is the act of decomposing a problem. Deciding which blocks depend on which is the act of architecting how the thinking will flow. This is the meta-cognitive layer of the work. Reasoning about the shape of the work before doing it.

Agents in ThruWire are expected to operate here. When Claude is handed a hard problem inside a ThruWire project, the first move is not to produce an output. The first move is to think about the shape of the work and write it down as structure. Decompose the problem into blocks. Declare the dependencies. Draw the isolation boundaries. Evaluate whether the structure it authored actually serves the reasoning it is meant to hold. When the structure is wrong, rewrite it. Then run the work inside the structure it just built. This is a behavioral expectation the harness imposes on agents, not a capability they happen to have access to. An agent in a chat app, given the same problem, would start writing the output. An agent in ThruWire starts by authoring the graph.

Claude in ThruWire is a meta-cognitive teammate. It does not just do the work. It decides how the work should be shaped, writes the shape down, and then does the work inside it.

ThruWire is a harness. The harness is extensible by the humans and agents working in it, who build a graph of structured blocks together. Four properties make that extension work.

• Explicit dependencies. A block cannot consume an artifact it did not declare. The edges are written, readable, and enforced at runtime. Any participant who opens the graph can see what each piece was built from by reading the edges.
• Isolation boundaries. A block cannot see upstream artifacts it did not declare. A landscape scan that cannot see the product docs produces research that is not reverse-engineered from the solution. A pressure test that cannot see the reasoning that built a claim produces an evaluation that cannot rationalize it.
• Execution identity. Every block execution has a structural fingerprint computed from its position in the graph, its inputs, and its dependencies' artifacts. Same fingerprint, same result, cached and reused. Change one block, and the system knows precisely which downstream blocks need to re-run and which can stay.
• Typed artifact contracts. Every block produces a defined output for defined downstream consumers. Intermediate work is preserved for inspection but does not leak into downstream context.

Once the harness is extensible and externalized, attention shifts. In a single-player harness, you iterate on an output. Describe what you want, see what comes back, adjust, try again. The unit of work is the artifact in front of you. You are vibing the output.

In a multiplayer harness, the unit of work is the graph. You are iterating on the system that produces decks, not on the deck. You are adjusting the block that generates research summaries, and every downstream artifact updates in turn. You design the primitives, and the model executes inside the design. You are vibing the system.

Systems thinking is a consequence of the harness being externalized. When the structure is the authored object, you think about the structure. When changing one block propagates through a graph, you learn to find the intervention point before you intervene. The behavior is true for humans and for agents. Both participants reasoning about the shape of the work, because the shape is something they can see.

The standard assumption is that better models absorb the structure. A model that can decompose problems into well-shaped graphs and manage dependencies on its own shrinks the human's role to approval. Defer to the model.

This gets the direction wrong. The problem does not disappear when agents get better at structure. It moves up a level.

A founder today manages a positioning exercise. A founder in 2027 with stronger agents does not manage one positioning exercise. She runs five of them in parallel, across five market segments, each with overnight competitive scans, audience profiles, and narrative drafts produced by agents that can author well-shaped graphs on their own. The number of blocks in her project did not stay constant and the human role did not shrink. Both grew. The graph she is reading is ten times larger and the decisions she is making are at a higher level of abstraction, but she is still the one holding the shape of the work. She is still the one deciding which branches to extend, which to prune, and which findings to carry into the investor narrative.

The harness is what makes the bigger loop tractable. If the blocks agents author are ephemeral, shaped by runtime inference and gone when the loop ends, the founder is back in the old world with five times the work. If the blocks are externalized, authored, and inspectable, she can read what the agents built, intervene where her judgment matters, and let the rest compound. The case for externalized structure does not depend on agents being weak. It depends on the work getting bigger. Better agents enlarge the work. Externalized structure is how the work stays coordinated at the new scale.

Better models do not shrink the human's job. They grow it, and they grow their own. The problems move up a level, and the graph is how the participants stay coordinated at the new altitude.