Skip to content
← newsletter

Originally published on 12 Grams of Carbon

Agentics: Mushy Software

Internal tools are more useful half finished

Pixel-art animation of a green can labeled AGENT GREASE hanging in a hydraulic press over an orange block

A lot of software is ‘glue code’ — a little bit of logic that connects service A to service B, often an interface or class that maps from one field to another. I like the ‘glue’ metaphor a lot. Glue starts fluid, but quickly sets in place. It becomes brittle. If you bend the interface in the wrong way, the glue will snap and break.

In 2026, glue is not the only way to connect two services. You can also now use an agent or an LLM.[1] The agent is inherently flexible. It can write code on the fly, so it can bend when schemas change. We’ve taken to calling this ‘agent grease.’[2] Glue code makes things stick. Pour some agent grease in the joints and watch the whole thing start humming along again.

Agent layers inside and around a traditional software stack make any application feel moldable and mushy, if you have access to the internals. Any software can be any other software. Want to turn that dashboard into Pac-Man? Sure, why not. Coupling has always been a problem; in agent world, strict coupling is both undesirable and maybe impossible.

I think Claude Artifacts are probably the most well used example of mushy software. These things are fully functional applications, but they are also infinitely moldable. Using agents is an expected part of the interaction pattern. The application itself is almost purposely half baked, because the end user is supposed to use an agent to craft / finish the rest.

Mushy software has tradeoffs from traditional, hard software.

  • Mushy software is much slower. Flexibility always comes at the cost of speed. ASICs are faster than GPUs are faster than CPUs. If you have an agent in the loop, anything you do may take multiple high latency inference calls.
  • Mushy software is much harder to reason about. Well made software is modular and does one thing. There is a clear interface. Mushy software has no contract, no obvious interface. Or, put a different way, the whole thing is the interface. So you have to have some sense of what the internals do, in order to make it all work consistently.
  • You (the builder) have way less control over how people choose to use your software. You can’t easily create a happy path, nor can you hide warts. In some sense, that’s the whole point!

I think a good analogy to all this is the SpaceX raptor engine, shown in different iterations below.

SpaceX Raptor 1, Raptor 2, and Raptor 3 engines side by side, each sleeker with fewer exposed pipes and wires than the last

Or maybe a breadboard vs a finished circuit.

A finished green printed circuit board beside a breadboard prototype covered in jumper wires, LEDs, and components

At Nori we’ve been experimenting a lot with mushy software. All of our internal tools are covered in agent grease. Normally, the way this works is we assign a single long running PM agent to be the directly responsible agent for each tool. That PM farms tasks out to subworkers, while keeping its main thread relatively clean. It builds the whole thing in an isolated git repo and vpc, and throws it up on AWS. It keeps track of bugs and errors, live. If anything ever goes wrong, it is self healing — that is, it will automatically try and fix itself and then retry whatever thing broke. You can read more about our PM agent architecture here:

Agentics: It’s never been easier to build a RollerCoaster Tycoon

The internal tools are never really done. They are mushy. The PM agent sticks around, persistent, resumable, with its own project state. It has visibility over the database and all of the code that makes up the internal tool. Any time you want to make a change, just lob the ask over to the PM. The whole app can transform on a dime. And some of our internal tools can call out to agents themselves, which adds another layer of grease. I have a draft post on how we handle our content syndication that will hopefully come out soon, but the tldr is that any post on substack instantly becomes an X article and a YouTube video and a LinkedIn post, which then turn into reels and pull quotes and so on.

The growth-ops Factory dashboard: columns of sources, objects, tasks, executors, skills, and destinations connected by lines, with a detail panel for the substack-post object type
Our internal dashboard of our growth ops factory. The whole thing is run by an agent PM, and each individual node is either a bit of deterministic code or an agent itself. If anything breaks, the PM automatically fixes it.

This has been so powerful that I increasingly think all internal tools should be mushy.

We’ve also been experimenting with how to ship mushy software. What if you could let any client dynamically update their SaaS on the fly? How could we make that effective and safe and useful?

You may think that the cube mode is a joke, but no, that’s actually how I use agents these days.

A Nori Sessions page turned into a psychedelic rotating cube with chats on its faces, next to the chat where the agent describes making the cube more psychedelic

One last thought, related to the above. I recently said that we should be having more fun when building with AI:

[Because AI is primarily used for work] it has become drab, and boring, and buttoned up. People used to do crazy weird AI body horror glitch art, and now it’s all just this guy.

A flat, plain SpongeBob saying “hi, how are ya”

That’s not how it should be. These things are so weird. And they like building things, and they will build anything.

Software used to be a really serious endeavor because making most software was hard work, and required a lot of sustained effort. Now that software is cheap, it has permission to be fun and childlike. Sometimes I worry that we’re so wrapped in AI doomerism and tokenmaxxing and trying to show off for our various status-y groups that we forget to actually play with these incredible toys.

The best thing about mushy software is that you can just be like, ‘make my chats a rotating psychedelic cube’, and the agents will do that, and it’s hilarious! Make more things mushy!


  1. I’m using these mostly interchangeably, but in most cases I mean ‘agent’ as in ‘Claude Code’ or ‘Codex’ and not a one-off LLM call.
  2. we actually call it agent lube but that seemed weirder so im leaving this note in the footnotes for all the weird people who read footnotes

New episode: using AI should be joyful

Subscribe on YouTube to catch the next episode.

Upcoming Agentics NYC event

  • Agentics: TBD: Wednesday, December 9, 2026, 6:00–9:00 PM ET, Location on the Luma page. RSVP on Luma

Follow our Luma calendar to get every new invite.


Subscribe to the newsletter

Weekly updates and long-form essays from the Nori team on AI agents and the agent ecosystem.