# Agentics: Mushy Software

> Source: <https://12gramsofcarbon.com/p/agentics-mushy-software>
> Published: 2026-11-18 06:46:14+00:00

**Recommendation:** Give each internal tool a single long-running PM agent with its own project state that delegates to subworkers and self-heals by fixing and retrying failures, accepting slower, harder-to-reason-about software in exchange for moldability.
More in the playbook "Designing agent systems": <https://wpnews.pro/playbooks/agent-architecture>

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](#footnote-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](#footnote-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.

Or maybe a breadboard vs a finished circuit.

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:

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.

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.

One last thought, related to the above. I recently said that [we should be having more fun when building with AI](https://12gramsofcarbon.com/p/agentics-using-ai-should-be-joyful):

[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.

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!

*If you want to see more of our mushy software, follow [Jiro (our internal Nori agent) on Twitter](https://x.com/noriagent) or [me on substack](https://substack.com/@theahura?utm_source=user-menu) or join [our Agentics community slack](https://join.slack.com/t/nori-7sp2119/shared_invite/zt-47a0avfoj-RHQCoGcuAer4pThFPTMh7w).*

*Agentics is the study of how to use and reason about agents. Learn more about how to use agents at our [agent learning hub](https://agenticsnyc.com/learn.html).*

*If you want AI employees, we can help! Nori is a platform to build and deploy AI employees. Check out [noriagentic.com](https://noriagentic.com/?utm_source=substack&utm_medium=email&utm_campaign=substack-amol-2026-10) for more.*

[1](#footnote-anchor-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](#footnote-anchor-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
