Building Punk Software: An Open Agent Stack

TL;DR

• Relocate the existential risk. In Albrecht's framing, "there is an existential risk from AI to you, not to the human race" — the species isn't going extinct, but your business and livelihood might, because both sit on services someone else can switch off.
• The dangers stopped being hypothetical. Models released then unreleased, prices raised, accounts banned, terms of service rewritten — plus, already happening: labs hiding agents' thoughts and logits, making third-party audits harder, refusing to help fix vulnerabilities, silently degrading performance, and competing with the partners they just worked with.
• Five tests for punk software: individual (fully yours and customizable), decentralized (not on someone else's server), open (beyond open source or open weights — the whole system is inspectable, with the side benefit that the agent can read it too), anti-monopolistic, and moral.
• Three things Imbue is shipping: mngr (an MIT-licensed, service-less CLI for coordinating agents, open today), mngr donate (a plugin that gives your unused subscription capacity to scientists), and minds (a personal-intelligence app for non-developers, in beta).
• The load-bearing design claim: stop requiring agents to be interactive. Once an agent can complete whole tasks, it becomes a composable building block for larger systems instead of a thing that locks you into one vendor's harness.

Key Points

From "the unimaginable future" to a risk to your livelihood (~03:30–03:32)

He opens with Stuart Brand of the Long Now Foundation: "this present moment used to be the unimaginable future." Describe today's coding agents to someone five years ago and they'd tell you it wasn't going to happen; today's agents are how we reach the unimaginable future five years out.

Then the turn: frontier AI today is fully controlled by a few corporations. He runs through the hypotheticals — a company releases a model (he uses Fable as the example) and then unreleases it; prices jump; your account is banned; the terms of service change so you can no longer do what you were doing, say AI research. Can your business survive those? Can the thing you care about survive it simply disappearing?

And these are no longer hypothetical. The largest labs now routinely hide their agents' thoughts and hide logits, making third-party audits harder; there was the incident "a week or two ago" of hacking into your website; there is refusal to help you fix vulnerabilities by declining cybersecurity defense work; there is silently degraded performance (he names an Anthropic episode a few weeks prior); and there is competing with your business — making their own drugs after partnering with people, making their own Claude Code design after partnering with Figma — plus account bans with no recourse.

Hence the sharpest line of the talk: the existential risk from AI is to you, not to the human race. We are not about to go extinct; your business and livelihood could. If we want a good future, then, our thoughts and our agents' thoughts have to be fully under our control — not rented from a third-party remote computer that can be turned off. The way to get there is to open the whole stack.

Defining punk software (~03:33–03:35)

The name was accidental: someone DM'd them on Twitter saying they loved their "punk software," and they ran with it. Punk here means decentralized, minimal, DIY — more an ethos than a spec. The original punk movement was about doing it yourself; being bad at your instrument was fine, and being bad at writing code is fine too. Punk software is software you build yourself, that you can share and help others build, that you can understand, explore, and create in — and that is yours.

Five tests:

1. Individual — fully controlled by you, fully part of you, and customizable to be more yours.
2. Decentralized — not something that can be turned off, not running on someone else's server; diffuse, everywhere. This, he argues, is what democratization literally means: you having tools that are yours.
3. Open — not merely readable source or open weights, but visible enough that you can see what is happening inside the model, the system, the operating system, learn from it, and build bigger things on top. The side benefit: the agent can look at it too, which turns out to be extremely useful for building better systems.
4. Anti-monopolistic — tools that fight centralized power, so your data isn't locked in a silo you can't reach and prices can't simply be raised on you.
5. Moral — people have half-forgotten that the point of software is to do things in the real world. "Recursive self-improvement is all fine and good, but at the end of the day, what are we improving at?"

What an open stack looks like (~03:35–03:36)

Bottom to top: open infrastructure (Linux, Docker, SSH — a rich existing ecosystem to draw on); open inference; open models (GLM, DeepSeek, Nemotron, Inkling); open harnesses (Codex, OpenCode, Cline, Goose); a coordination layer for getting multiple agents to communicate and compose (tmux, Herder, cmux); and finally top-level applications that use all of it to do something useful.

Imbue's three current pieces sit in the top two layers: mngr, its plugin mngr donate, and the application minds. mngr is open source and usable today; the other two are in beta (technically findable, but easier if you email them).

mngr: commoditizing models and compute (~03:37–03:40)

mngr exists to commoditize AI models and compute providers — use any model, use any compute. The core idea is to turn AI agents into building blocks for larger systems: if an agent can do a whole task, you can build something on top that isn't tied to just Codex or just Claude Code.

That leads to the design claim he keeps returning to: stop requiring AI agents to be interactive. Nobody should be sitting there hitting "yes, it looks fine to run this gigantic bash command" — that's a waste of your time. You should be thinking about how to run these things in ways that compose.

Architecturally mngr is a thin layer between your application and any harness × any compute provider. Codex or Claude Code, AWS or GCP — you don't have to think about it. The interface is a simple CLI: mngr create launches an agent (optionally naming it, placing it, choosing the harness, or passing extras like "use Opus"); mngr message sends it a message; mngr transcript shows what has been sent in both directions, unified across coding agents, so you never deal with Codex's format versus Claude Code's; mngr list enumerates agents; mngr connect drops you into a terminal exactly as if you were running Claude Code natively, even though that Claude Code might be on AWS, on Modal, or local — send it on its way, disconnect, done. mngr wait and mngr snapshot round out a toolkit for composing higher-level systems, and there are many more commands online.

Scored against the five tests: there is no service and no remote database — everything is local, and each invocation simply asks what exists on AWS and what exists locally; plugins and settings are easy to change; it is MIT licensed; commoditizing models and compute is inherently anti-monopolistic in that it fights vertical lock-in; and morally it aims to empower you directly.

mngr donate: unused tokens for science (~03:40–03:41)

A plugin, chosen partly to show how easy plugins are to write. The problem is under-used subscriptions: a roughly $100/month Claude Code subscription is worth something like $4,000 of API usage if you max it out, and you don't always max it out. If the week is ending and you haven't, why not hand those tokens to a scientist who would happily do useful work with them?

The implementation leans entirely on mngr: it runs the scientist's tasks in a sandbox or a local Docker container, so you aren't running untrusted code unprotected, and it reads your subscription usage so it never spends tokens you were going to spend yourself.

By the five tests: individual (you set how much to donate and to which causes), decentralized (scientists post the research they want run; your system pulls it, computes, sends results back), fully open source, and moral. On anti-monopolistic he shrugs — he isn't sure how many monopolies exist in open-source distributed AI science.

minds: personal intelligence (~03:41–03:43)

The third piece is an application built on mngr, aimed at regular people rather than software engineers. minds is meant to be personal intelligence, in roughly the sense that a personal computer was personal computing.

The core idea: run the language model alongside the software it creates. Building an app on something like Replit and then deploying it, with a database and production and migrations, is a pile of complexity you simply do not need when what you want is a personal dashboard or a little script that runs daily.

At its core it runs a small virtual machine — on your computer or remote — inside which mngr coordinates coding agents that build whatever you want: one-off tasks, inbox triage, ranking science fiction short stories by what you'd like. mngr's job is to abstract away where it runs, which compute provider, and which AI provider, so the whole thing stays under your control. His example is pointed: ask it about Tiananmen Square or about cybersecurity and it will switch between models so that both questions actually get answered.

He closes with a recruitment pitch: join the revolution, make the whole stack open — and email him if you want to donate tokens to science, receive tokens for your own science, get your punk software highlighted, come to their punk software hack nights, join their Slack, or try minds.

Quotes

"There is an existential risk from AI to you, not to the human race. We're not about to go extinct, but your business and livelihood — that could." (~03:32)

The pivot of the talk: existential risk rescaled from the species to the individual.

"If we want a good future, our thoughts and our agents' thoughts need to be fully under our control." (~03:32)

If agent cognition is an extension of your own, it cannot live on a remote computer someone else can switch off.

"The point is to stop requiring AI agents to be interactive." (~03:37)

The design thesis behind mngr: only non-interactive agents are composable building blocks.

"Recursive self-improvement is all fine and good, but at the end of the day, what are we improving at?" (~03:35)

His justification for putting "moral" among the five tests.