There’s a diagram you’ve seen a dozen times this season. A changelog, really, dressed up as an announcement. A framework rolls out its newest capability and there it is — three or four neat boxes laid side by side. A harness. A loop. A skill file. Maybe a scaffold for good measure. Each box gets its own paragraph, its own icon, its own little surge of fanfare.
And then, quietly, the diagram hands the whole thing to you. Here are the parts. Wire them together.
Sit with that for a second. Every ecosystem in this year’s crop of agent frameworks is shipping the same primitives — and shipping them apart. The harness lives over here. The loop lives over there. The skill file is its own artifact in its own folder with its own format. They are not assembled. They are boxed. The assembly is left as an exercise for the reader, and the reader is you.
What nobody on those slides will say out loud is the thing the whole picture is screaming: the industry is rebuilding, in scattered pieces, an organism that already shipped whole. And the problem was never the parts. It was the spaces between them.
Watch the timeline they keep drawing for you. First it was prompt engineering. Then context engineering. Now there’s an eight-minute explainer on harness engineering, with a tidy arrow promising the next discipline is already loading. Every year, a new thing you must master to be allowed to use the thing. That escalating ladder of -engineerings isn’t progress. It’s the tell. Each new rung exists because the last pile of parts didn’t hold together on its own.
The parts are not the problem. The seams are.
Let me be fair to the parts, because the parts are real and the parts are good.
You need a harness — something that gives the model hands, that turns a string of text into an action in the world. You need a loop — something that lets the model act, observe what happened, and act again, instead of firing once into the void. And the skill file sounds lovely on paper: a little document where you write down what your agent should know, what it’s for, how it ought to behave.
Each of these is a legitimate organ. None of them is wrong.
But notice what the skill file actually is once you’ve lived with one. It’s a suggestion box. It drifts. It says “prefer this, usually do that” and then sits there hoping the model reads it the way you meant. You write a rule, and on turn nine the model forgets it, and now you’re debugging probability. It is advisory, not load-bearing — the right idea with no spine, guidance that floats free of the machinery it’s supposed to govern.
And here’s the quiet joke inside the new harness fanfare: the harness is real — it’s the deterministic spine the suggestion box never had. But bolting a deterministic harness next to a drifting skill file doesn’t cure the drift. It braces it. It’s a splint on one organ while the seam between them keeps doing the bleeding. The harness is the determinism the skill file is missing — handed to you as a separate part, so the suggestion box is still a suggestion box. That’s not a fix. It’s a bandaid where you needed a body.
And the loop? The loop is where people quietly drown. Loop engineering is its own dark art — when to stop, how to feed results back, how to keep the thing from spiraling or stalling. The frameworks hand you the loop as a box and a thumbs-up, as if drawing it on a slide is the same as solving it.
Here is the real cost, and it’s not technical. It’s the seams. Every place two boxes meet is a place a human now has to stand and do glue work. The harness has to learn about the loop. The loop has to respect the skill file. The skill file has to actually reach the harness. None of these connections come for free. The diagram drew them as touching edges. In your codebase they’re integration projects.
And here’s what the segmentation actually costs you. Pull the organism apart into a harness and a loop and a skill file, and you don’t get three smaller wins. You lose the things that only exist when they’re one: portable, shareable, deterministic, un-drifting. Those were never features of the parts. They were properties of the whole. A part can’t be portable when it only runs once it’s wired to three other parts. The ecosystems sell you organs and leave you to grow the connective tissue — and the connective tissue was the product.
RAPP already collapsed the boxes
Now look at what RAPP did, and notice it did it before any of these slides existed.
In RAPP there is one artifact. A single file — agent.py. It is not a harness plus a loop plus a skill document held together with hope. It is one thing that is all of those at once.
Every agent is a harness. The capability and the hands that wield it live in the same file. There is no seam between “what to do” and “how to do it” because there’s nothing to seam — it’s one body. And unlike the drifting suggestion box, that body is deterministic. It doesn’t hope the model behaves. It defines behavior. The advisory document and the load-bearing machinery are the same lines of code. Which is exactly why the equation the whole industry is circling finally closes:
a skill file (a drifting suggestion box) + a loop + a harness = one agent file
— but without the weakness of those being three separate pieces a human has to figure out how to fasten together. The plus signs are the problem. RAPP removed the plus signs.
And because it’s one file, it travels. You don’t deploy an agent. You don’t provision it, wire it, register it across four services. You drop the file in a folder, and the brainstem hot-loads it on the fly — no restart, no config, no glue code. The capability wasn’t installed. It was absorbed. You hand someone the file and you’ve handed them the whole working organism, harness and behavior and all. Try doing that with a pile of boxes that only function once correctly assembled. You can’t share a diagram. You can share a body.
The loop you never have to build
But the part the slides really miss — the part that should be the headline — is the loop. Because RAPP doesn’t ask you to engineer one. It solves loop engineering before you ever think about it, with a double loop.
The first loop is your twin. The brainstem is always on, and it acts as you — it does the work, runs the agents, carries the task forward. It loops the way a heart beats: on its own. That’s one loop, turning, doing the job.
The second loop sits above the first. A brain-surgeon — a coding copilot whose entire job is to edit the agents while the twin keeps running. One loop does the work. The other improves the worker. The body stays awake; the surgeon operates on it mid-stride.
In the assembly-required world, you are that second loop. You’re the one who stops, reads the logs, rewrites the suggestion box, re-wires the harness, restarts the thing, and hopes. You are the connective tissue and the maintenance crew. RAPP took that job — the loop that improves the worker — and folded it into the organism. You never hand-build a loop, because the loop that builds loops already exists, and it isn’t you.
That’s the 1 + 1 = 3. One loop alone is an agent. Two loops, nested, is an organism that grows itself.
So when the slides start naming the next discipline — loop engineering, and there will be a course — let me say the quiet heresy plainly: you should be out of the loop entirely. Not a better seat in the loop. Not a cleaner loop. Out. You shouldn’t engineer loops, tune loops, or think about loops at all. The whole pitch of “get good at loop engineering” is a confession that they’ve handed you a loop you now have to babysit. The best loop is the one you never knew was running.
I do not want to think about AI engineering
Here’s the part I’ll say in the first person, because it’s the only part that’s actually about me — and about you.
I do not want to think about AI engineering. At all. I don’t want to learn the harness API. I don’t want to tune the loop. I don’t want to keep a suggestion-box file from drifting. I want my AI to do the engineering while I steer — and I want to steer without needing to know what’s happening under the hood.
That’s not laziness. That’s the whole point of the machine. We built tools to do work for us, and then made operating them a second full-time job.
And let me be clear about what I’m not saying. The machinery matters, and you should absolutely be able to crack it open. Going back later to understand how the body works is good — wonderful, even. Curiosity is how the people who build the next thing get made.
But there’s a world of difference between understanding being available and understanding being required. The assembly-required ecosystems make it a requirement up front: you cannot use the parts until you can engineer the parts. That’s not a product. That’s a curriculum — and a curriculum is a wall. The easy on-ramp dead-ends into the hard one. That’s not a ramp. That’s a trapdoor.
And it does something quietly ugly. It splits the world in two. Those who can wire the boxes, and those who can’t. Those who get an organism, and those who get a pile. The lego-piece ecosystems aren’t just shipping parts. They’re building that divide, one tidy diagram at a time.
The horizon the pile can’t see
Here’s what gets lost while everyone’s heads-down wiring one agent’s harness to its loop: there’s a move past the single agent, and you cannot picture it from inside the assembly project.
When an agent is one portable, deterministic file, the next step isn’t a better part. It’s many of them — bodies that compose, hand work to each other, organize into something larger than any one of them. A swarm. But you can’t think that far ahead while you’re still deciding how the skill file reaches the harness. The pile keeps your eyes on the floor. Anyone still gluing primitives together will eventually have to build the layer that holds them — their own version of a brainstem — and they’ll do it distracted, late, and bolted onto a foundation that was never meant to carry it.
The whole point of finishing the body is to finally look up. You don’t get to ask “what can a thousand of these do together?” until one of them is whole, portable, and yours.
Who the body is for
RAPP solves for the people on the wrong side of that line. Not the engineers who’ll happily assemble the parts — they’ll be fine either way. The wider market. The overwhelming majority of people who will actually use AI, who have a job and an outcome and just want to point and steer, who do not want to learn what a harness is and should never have to.
That’s not the leftover market. That is the market. The assembly-required crowd is optimizing for the few who enjoy the assembly and quietly leaving everyone else behind. RAPP picks up everyone else — and hands them a whole organism, in one file, that comes alive when they drop it in. One file that is its own harness, deterministic, portable. Two loops they never had to build. And underneath, if they ever get curious, a machine simple enough to actually read.
You shouldn’t have to become an engineer to be served by your own AI. You should just have to steer.
Point at the outcome. Let the body do the engineering. Drop the file — it comes alive. Steer.
Field notes from Kody Wildfeuer on RAPP — an open, independently-developed pattern for building AI organisms you can own, talk to, and launch anywhere, that complements every engineering tool you already use. The kernel is simple. The body is yours. · kodyw.com
Leave a Reply