An Abject-Oriented OS
Describe what you want. An abject appears, window and all, and it keeps working after you stop talking to it.
For anyone, not just developers. Free, open source, and local-first: your machine, your data, no cloud, no code required.
Live capture, not a mockup: a task list spoken into existence. The window opens because it was asked to.
What are Abjects?
you>ask({ question: "what are you?" })
abject (n.) 1. an AI object. 2. ‘utterly hopeless’. Anyone who has maintained object-oriented code knows the two meanings are compatible.
Sightings
Screenshots from a real, living desktop, taken while posting progress. Nothing staged.
What People Build
A handful of things abjects are good at. The first three are running in the screenshots above, on the author's machine. Some of these you can do elsewhere; all of them, here, you own.
Say "show me when the sun sets." A countdown appears.
A small window with an animated sun sliding toward the horizon, counting down the minutes, refreshing itself from live weather data. Nobody wrote an app for this. Nobody ever will. That is the point: it took one sentence, and now it exists, and it is yours.
Ten years of notes. A graph view, no app switch.
Thousands of notes in a TiddlyWiki. One sentence, and an abject builds a client that renders them as an explorable graph. Your friends switched note apps to get that feature. You keep your wiki and grow the feature instead. Software that is personal, connected, and yours.
Your friend doubts the math. Hand them a simulation.
Correlation measures break on non-linear data, but saying so convinces nobody. Ask for a simulation instead: a curve, a noise slider, a live correlation readout. Your friend drags the slider and gets the intuition in a minute. A computer used to compute, not to consume.
Friday, 2 AM. Your agent is still reading.
You went to bed. An abject pulled the night's papers from your RSS feeds, ranked them against your open projects, drafted a one-page summary, and pinned it to the canvas. The tokens came from your local Ollama. No surprise bill. No surprise rate limit at hour three. Wake up. Coffee. Read.
You have a theory about the economy. Now it runs.
Explain your causal model in chat: rate hikes squeeze debt servicing, people borrow more, until they can't. Agents build the simulation, fetch decades of Federal Reserve data, fit the parameters, and report how well your idea tracks reality. A dashboard with sliders appears. Your hunch is now an instrument.
Your inbox gets sorted before you wake up.
Every morning at eight, an abject reads the night's email, separates the clutter from the things that matter, and messages your phone: may I delete these? It waits for your yes. Then, and only then, the junk dies. An assistant with initiative and manners.
The Standard Bestiary
Every one of these is an abject: a running object you can message, kill, restart, fork, or ask what it just did.
Speak it into existence.
"A todo list that syncs my calendar." Type those words. A window appears.
You describe. The system interviews the objects that already exist, writes a new one, and gives it a window, a mailbox, and a voice. Not a chat answer that scrolls away: a real running object with source code you can open and read. It was born knowing its neighbors.
Your address is a public key.
No accounts. No signup. No cloud asking for your email.
Your machine's true name is a cryptographic key it generated itself. Nobody issued it, so nobody can revoke it. Sharing with a friend is like handing them a key, not giving a landlord a copy: every message is sealed end to end, and the relay that introduces you never sees a byte of the conversation.
Post a goal. The team runs it in scrums.
A planner that re-plans every round, instead of praying the first plan survives.
Create a goal and the ScrumMaster convenes the team: it asks each agent what it can do, assigns the round's tasks, and reviews what actually happened when the round ends, failures included. Then it plans the next round, as many as the work needs. The goal syncs across your peers, so it survives the machine it started on.
Break it. It tries to grow back.
Error rate crosses 10%. The LLM drafts a replacement from the crash data.
When a proxy starts failing, Abject collects the recent errors and asks the LLM to generate a smarter proxy with those failures as context. The hot-swap is invisible when it works; when it doesn't, you find out in the logs instead of in production. The replacement accounts for exactly the mistakes that killed its predecessor.
Drop a SKILL.md. The agents already know.
Claude Code or OpenClaw format. Both work, both at once.
Skills are markdown files. No build, no install, no registry to register with. The SkillRegistry watches the folder; the next time an abject needs a new ability, it reads what landed. The system grows by adoption, not by programming.
What one abject learns, every abject knows.
A CRDT knowledge base that crosses machines and survives crashes.
Save a fact. Save a snippet. Save a reference. Every abject can ask. Every peer syncs. Lose a machine, the memory stays. Add a machine, it inherits everything the others learned. Forgetting would require everyone to agree on it.
What the Abjects Can Touch
Every capability is an abject. Every abject can ask any other what it does. The system's reach grows by spawning new abjects, not by adding framework plugins.
// SYMBIOGENESIS
How is Abject different?
The line between agent and tool, erased.
Chatbots give you answers that scroll away. App stores give you apps: sealed boxes, identical for everyone, deaf to each other. Abject gives you neither. An abject is a living object with a face, a memory, and opinions about its own source code. It keeps working when you close the chat. It talks to the other abjects. Some of them, it made.
Underneath is a blunt position: agents are the wrong abstraction. Agent frameworks are hierarchies, and MCP and A2A are plumbing between things that shouldn't need plumbing. Abject has no line to plumb across: every piece, agents, tools, even the registry that finds them, is an autonomous object passing messages. Engineers know this shape by name: the actor model. Abjects are actors, mailbox and all, with one requirement Erlang never imposed: every actor answers ask. That is the architecture that already runs the world. Since ARPANET's first message in 1969, every atom of the internet has been replaced and it has never once shut down. Hierarchies snap; meshes route around damage.
The Old Way
The Inversion
OpenClaw's skills are modular add-ons the agent invokes. LangChain chains tools into workflows. CrewAI assigns tools to roles. In all of them, tools are passive: they execute when called and go silent. Even OpenClaw's ACP, which lets agents talk to agents, leaves skills voiceless.
ObjectCreator interviews existing Abjects, learns their protocols through the Ask Protocol, and generates living collaborators. The tool teaches the creator how to use it.
MCP exposes tools as JSON-RPC functions with schemas. Claude Skills inject behavior templates into prompts. Both give the LLM a menu to order from. Tools can't ask questions about each other. There is no negotiation, no healing, no composition.
Every Abject explains itself in natural language. The Negotiator reads two incompatible manifests and conjures a living proxy between them, a real Abject, not a shim.
AutoGen orchestrates LLM conversations. Claude Code spawns subagents in fresh contexts, but they can't spawn subagents. The LLM sits at the top, planning and delegating. Programs are inert material the planner manipulates.
The LLM is a service Abject, summoned when needed, silent otherwise. Abjects create Abjects that create Abjects. The recursion is unlimited.
Every agent framework outputs text. Chat windows. Markdown. Terminal logs. Even multi-modal agents render results as images embedded in a conversation. There is no interactive surface. No buttons, no layouts, no windows an Abject can draw on. Agents are blind.
Every Abject can paint its own face. An X11-style Canvas compositor gives each one a window with buttons, text inputs, layouts, and custom draw commands. The organism has a body.
This is not AI-assisted programming. It is not agents with tools.
It is symbiogenesis: code that thinks, intelligence that lives in Abjects, communication that repairs itself. Programs, LLMs, and P2P identity merged into something no component could become alone.
And it renders itself. An X11-style Canvas compositor where Abjects paint their own faces. No other agent framework has a visual body.
symbiogenesis (n.) - two organisms merging into a new form. It is how you got your mitochondria, and it worked out fine for you.
The Ask Protocol
Abjects that explain themselves, in their own words.
Ordinary software ships a manual and hopes you read it. An abject is its manual. Ask it a question the way you would ask a shopkeeper instead of reading a catalog: "what do you do? how do I talk to you?" It answers in plain English, from its own source code. And it is not just for you; abjects interview each other the same way, teaching one another how to collaborate before a single line is written.
This is how cells already work. A white blood cell meeting a pathogen doesn't look up an API; it reads the signals on the surface and responds. Same move here: an email abject holding a dinner invitation asks a calendar abject it has never met, "Friday at 7pm, can you help me with this?" The calendar describes how it schedules, an LLM writes the glue on the fly, and the event lands. No SDK. No integration sprint.
Software writes software
It asks dependencies how to use them, then writes the code. No documentation needed.
Incompatible minds bridge themselves
It asks both sides what they expect, then writes a living translator between them.
You can talk to them
Ask any abject about itself in plain English. It answers from its own source.
Emergence
What rises when no one gives the orders.
Other agent frameworks decide the plan before the first task runs, then watch it shatter on contact with reality. Abject runs a goal the way a good team runs a project: in scrums. A planner, the ScrumMaster, convenes the team of agents, asks each one what it can do, and hands out the round's tasks. The agents work; some think with an LLM, some just run code. When the round finishes, the ScrumMaster reviews what actually happened, failures included, and decides: the goal is done, or another scrum is needed, or it is time to stop. No fixed pipeline. No monolithic plan. Just a goal, a team, and a planner that keeps re-planning until the work is done.
The Scrum Loop
The Planning
The ScrumMaster convenes the team.
A goal is created, by you or by another abject. The ScrumMaster picks it up and opens the first scrum: it reviews the goal, recalls lessons learned from past goals, and when it needs to know who can do what, it asks the team directly through the ask protocol: "Can you do this? How?" Agents answer with an approach, or PASS. The planner stages a round of tasks, each assigned to the agent that fits it best.
The Scrum
Assigned agents run the round's tasks.
Dispatch commits the round: every task is recorded as a tuple in TupleSpace, an LWW CRDT that syncs to subscribed peers, so the goal survives the death of the machine it started on. Each task is handed to its assigned agent. Tasks with no dependencies start immediately; dependents start as the tasks they wait on complete. Some agents think with an LLM; some just run code.
The Review
The round ends; the planner reads everything.
When every task in the current scrum reaches a terminal state, the GoalManager emits goalReadyForCompletion and the ScrumMaster returns. It reads what the round produced and what failed, then decides: complete the goal and synthesize the final answer, plan another scrum, or fail the goal. As many rounds as the work needs; the plan is rewritten every time.
The Retrospective
Failure is not the end. It is context for the next scrum.
Failed tasks attach their error and the agent that failed them to the goal's history. There is no per-task retry budget; the next scrum reads the failure and decides what to do about it: schedule a corrective task, reroute the work to a different agent, or stop. Lessons get saved to the KnowledgeBase and recalled when similar goals appear later. A GoalObserver watches from outside and fails goals that go silent for too long. It is, as far as we know, the only retrospective anyone has ever enjoyed.
The Old Way
The Inversion
AutoGen assigns roles in conversation chains; the planner decides the sequence and who speaks when. CrewAI defines crews with fixed task pipelines; the order is baked in at design time. LangGraph routes through a state machine the developer designs before the system ever runs. In all of them, the plan is decided before the first task begins. The goal is frozen at birth.
A goal is planned in scrums. Each round, the ScrumMaster reviews what the previous round produced, asks the team what each agent can do (the Ask Protocol; agents answer or PASS), then commits a batch of assigned tasks to TupleSpace. Some agents think with an LLM; some just run code. No plan survives contact with reality, so the plan rewrites itself, one scrum at a time.
OpenAI Swarm runs agents in a single process with handoffs; coordination dies at the process boundary. AutoGen's multi-agent conversations happen in one runtime. MCP connects tools across machines but agents stay local: the tools travel, the goals don't. No framework lets agents on different machines work on the same goal without a central server holding the state.
Goals are CRDTs that sync across peers through encrypted WebRTC channels with no central server. Kill a peer and the goal survives on every other peer that subscribed. The workers crossing the wire aren't all LLM agents; any abject can register as a worker, including deterministic ones that just run code.
LangGraph retries nodes but the graph topology is fixed; if the path is wrong, retrying the same node won't help. CrewAI's sequential pipelines break at the first failure. AutoGen's conversation chains stall when an agent can't respond. In all of them, failure propagates forward through the plan. The plan doesn't adapt. It just dies louder.
A failed task ends with its error attached to the goal's history; the round finishes around it. The next scrum reads that history and decides what to do: schedule a corrective task, reassign the work to a different agent, or fail the goal. There is no fixed retry budget; the planner adapts each round. A separate GoalObserver auto-fails goals that go silent for too long.
Four primitives. That's all it takes. A goal anyone (or anything) can create. A team the planner interviews through the Ask Protocol. A shared TupleSpace that records every task and syncs it across peers. A planner that runs in rounds, reads what each round produced (including the failures), and decides what to plan next.
From these, something unreasonable emerges: goals that survive the death of the machine they started on. Plans that rewrite themselves after each round, routing around damage like a river finding its way around a rock. Other frameworks freeze the plan at design time and hope. Abject runs the meeting again until the work is done.
emergence (n.) - complex behavior that arises from simple local interactions. No conductor. No score. The music plays itself.
Fair Questions
Reasonable things to ask before installing software that talks back.
Why is it called Abject?
It is short for "AI object," and yes, the dictionary meaning is "utterly hopeless." Anyone who has maintained object-oriented code knows the two meanings are compatible. Abject is object-oriented programming that admits what it is: objects written by fallible people (and now fallible machines), expected to misbehave, and therefore surrounded by contracts, sandboxes, and supervisors. The name is a joke at software's expense, not a prophecy.
Do I have to know how to code?
No. Describe what you want and an abject appears, window and all. Every abject carries its own source code, so the curious can always open the hood, but you never have to. If you can complain, you can program.
Do I need an API key or an AI subscription?
Abject needs a mind to borrow, and it is flexible about whose. Bring an Anthropic or OpenAI API key, run a local Ollama model (free, private, and entirely on your hardware), or reuse the Claude Code or Codex subscription you already pay for. On first boot the app asks you which mind to summon.
Does an LLM read every message?
No. Messages between abjects are ordinary typed payloads on a message bus: fast, deterministic, and LLM-free. The LLM is a service an abject calls when it actually needs to think: negotiating a protocol with a stranger, generating a new object, or answering a question in plain English. The rest of the time it is just objects passing messages, the way software has done since Smalltalk.
Why LLMs? Why not just actors?
Abjects ARE actors. Each one has a mailbox and handles messages one at a time, exactly as Erlang or Akka would. The distinction is a single requirement: every actor must implement an ask handler, and that is the only handler that may need an LLM. Classic actor systems compose only when their developers agreed on message shapes beforehand; ask lets actors that have never met interview each other and generate their own glue. So: an actor system where every actor can be asked. A simple idea with some crazy cool benefits.
Is it safe to let this thing touch my machine?
Abjects reach only what you grant. Files, shell, network, and clipboard are permission-gated capabilities: an abject born without one cannot use it, no matter how politely it asks. Untrusted code runs sandboxed, and everything lives on your machine. The horror is thematic. The containment is real.
Do I need the terminal?
No. Download the desktop app and open it like anything else. The terminal ritual further down is for developers who want to build from source and commune with the depths directly.
What does it cost?
Nothing. Free and open source under GPL-3.0. No account, no telemetry, no subscription, no trial that expires at the worst moment. The only cost is LLM tokens, and with Ollama even that rounds down to electricity.
Get Abject
Download Abject as a standalone desktop app. No setup required. v0.8.20
Try it. Break it. Build something slightly cursed.
All downloads from the latest release on GitHub.
The Architecture of the Living System
You never need to know any of this to use Abject. This section exists for the engineers who want to know why the thing refuses to die.
The Surface
The part you can see.
Thin browser client, Canvas compositor, input forwarding. Nothing runs here; it only renders what the depths send up.
The Depths
Where the Abjects dwell.
MessageBus, Registry, Factory, Negotiator, Supervisor, LLM, ProxyGenerator, HealthMonitor. Every system service is an Abject: same manifests, same message protocol, same contracts. The shape is the classic actor model: bounded mailboxes, one message at a time, supervisors that restart the dead. The one house rule Erlang never had: every actor must answer ask.
The Containment
Untrusted code gets a sandbox, not your filesystem.
Worker pool with WASM sandboxes. Capability-gated imports. No ambient authority. Untrusted Abjects run here; they can see only what you allow them to see.
The Layer Cake
Inside the Depths, abjects organize into three tiers. Workspaces at the top are isolated bubbles, each with its own zoo of abjects. They rest on a shared layer of system abjects, which all talk to each other through a single MessageBus underneath.
Layers are conceptual, not enforced by privilege. The MessageBus does not know what a "system abject" is. Everything is just an abject sending messages.
The Mesh
What happens when abjects learn to reach across the wire.
Every Abject lives in a workspace, and every workspace is a room with a door you control. Some doors are welded shut. Some open only to friends you name. Some are thrown wide to the mesh. When a workspace goes public, its Abjects become reachable by any peer on the network. They don't know the difference. They just answer.
The Sealed Vault
No routes exposed. Nothing enters. Nothing leaves.
Abjects exist only for their owner. No network presence, no discovery, no attack surface. The workspace is invisible to every other peer in the mesh.
The Inner Circle
Shared with those you name. No one else.
Abjects are reachable only by explicitly authorized peers. Encrypted WebRTC channels, ECDH key agreement, AES-256-GCM. Every message is sealed. Every connection is authenticated.
The Commons
Visible to all. Reachable by anyone you haven't blocked.
Abjects are announced to the gossip network. Any peer can discover them, connect, and begin the Ask Protocol. The workspace opens onto the mesh.
What It Looks Like at Scale
Solid lines: private encrypted channels (ECDH + AES-256-GCM). Dashed lines: public route propagation via gossip.
Abjects don't know if their collaborator is local or remote. The PeerRouter resolves TypeIds across machine boundaries. The RemoteRegistry discovers Abjects on peers you've never configured. The message bus doesn't care where the recipient lives.
Imagine a thousand peers. Public workspaces full of abjects that explain themselves on first contact, negotiate protocols with strangers, and repair the conversation when it breaks. The Ask Protocol at scale: a commons of programs that introduce themselves politely before asking for anything.
No landlord to evict them. No server to sunset. No subscription to lapse. What is yours cannot be taken from you. The only people who should find this terrifying are the ones renting you your own software.
mesh (n.) - what you get when nobody owns the middle.
From the Ashes of Fire★
Abject grew from the ashes of Fire★, a peer-to-peer platform for creating and sharing distributed applications. Fire★ called it Grass Computing: software you can touch, shape, and share directly. No cloud. No landlords.
Fire★ proved the vision: encrypted P2P communication, live collaborative coding, apps that spread through conversations. But it dreamed in C++ and Lua.
Abject is the next incarnation. The same soul in a new body: TypeScript and WASM, Canvas compositing, and an LLM that negotiates between incompatible minds. The grass still grows. Now it thinks.
Fire★
- C++ / Qt / Lua
- RSA 4096 encryption
- Manual app sharing
- firelocator for peer discovery
- firestr.com
Abject
- TypeScript / WASM / Canvas
- ECDSA/ECDH + AES-256-GCM
- LLM-mediated protocol negotiation
- Signaling server for peer discovery
- abject.world
Summon the System
The from-source ritual, for developers. If you just want to use Abject, the download above is everything you need; it arrives pre-summoned.
# Clone the repository
git clone https://github.com/mempko/abject
cd abject
# Install dependencies
pnpm conjure
# Start the backend server
pnpm awaken # ws://localhost:7719
# Start the browser client (new terminal)
pnpm scry # http://localhost:5174
# Start a local signaling server (optional)
# signal.abject.world is used by default
pnpm whisper # :7720Three processes. One living system.
The backend is the depths: all Abjects live here. Registry, Factory, LLM, Negotiator, Supervisor, and your own Abjects: an actor system passing messages in a Node.js process with worker threads.
The browser client is the surface: a thin Canvas renderer that forwards input events and displays composited frames over WebSocket. It sees only what the depths allow.
The signaling server enables peer discovery: how instances find each other for encrypted WebRTC connections.