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.
Needs a mind to borrow: an API key, a free local model through Ollama, or the coding CLI you already log into. You pick on first launch.
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
Captures 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 on the author's machine, in the captures above. The last three are the kind of sentence you type next; nobody has to write an app first. 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.
Download to First Abject in Five Minutes
What actually happens between clicking Download and having a running object that is yours.
- Itwo minutes
Install
Download the build for your machine and open it. The builds are not code-signed yet, so the OS pauses once: Windows shows "More info, Run anyway", macOS wants a trip through Privacy & Security, and a Linux AppImage needs a chmod +x.
Per-platform steps → - IIone minute
Pick a mind
On first launch the settings window opens by itself on the AI tab. Paste an API key, or point it at Ollama for a free local model (a running Ollama is picked up automatically), or choose the Claude Code or Codex CLI you already log into. Save.
Every provider it speaks → - IIIone sentence
Say it
Click Chat in the sidebar and type what you want: "a countdown to tonight's sunset for Seattle, with the sun sliding down as it goes." A window appears. Close the chat; the window stays and keeps refreshing. Every window's ? button shows what it can do and lets you ask it anything.
More things to ask for → - IVwhen you say so
Let it reach out
The first time an abject wants to run a shell command, read a file outside its sandbox, or browse somewhere new, a permission prompt appears and waits for your yes. Grant once, or set standing rules in Settings. Nothing touches your machine without a receipt.
How the containment works →
Things to say first, copied from real sessions:
- "When is low tide in Seattle tomorrow?"
- "Show me the Sun, the Earth, and the Moon, live, and keep it fresh."
- "Make a fish tank. The fish should get hungry."
- "Ask the tide widget what it can do."
How is Abject different?
Engineers know the shape by name: the actor model, with one house rule Erlang never had. Every actor answers ask.
Answers that stay.
A chat answer scrolls away. An abject is a running object with a window, a mailbox, and its own source. Close the chat and it keeps working: refreshing the tide chart, feeding the fish, watching the inbox.
No top. No bottom.
Agent frameworks put a planner on top and tools underneath. Here every piece, the tools included, is an object that can be asked what it does and can ask back. The LLM is a service an object calls when it needs to think, and it is silent the rest of the time.
Your key is your address.
No accounts. Your machine generates its own cryptographic name, peers find each other over encrypted WebRTC, and a goal started here survives on every peer that joined it. Nobody rents you your own software.
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. Drop one in the skills folder, rescan, and the next abject that needs that ability reads it. MCP servers you already configured for other tools are imported the same way, and a catalog browser finds more. The system grows by adoption, not by programming.
What one abject learns, its workspace knows.
A full-text memory, replicated to every peer in a shared workspace.
Save a fact. Save a snippet. Save a lesson from a goal that went sideways. Every abject in the workspace can search it, ranked, and agents recall it into later work. Share the workspace and the memory replicates to every peer over the CRDT; keep it private and it never leaves. Workspaces are the privacy boundary, and memory respects 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.
Runs on Your Terms
Abject needs a mind to borrow and is flexible about whose. Bring an API key, run a free local model, reuse a coding subscription you already pay for, or let a friend's machine serve you models over the mesh. Route cheap jobs to cheap models and the hard ones to the smart one; the four tiers (smart, balanced, fast, code) are yours to point anywhere.
- Ollama local, free, private
- PeerLLM a peer serves models to you
- Claude Code CLI the login you already have
- Codex CLI the login you already have
- Antigravity CLI the login you already have
- Anthropic API key
- OpenAI API key
- Google Gemini API key
- OpenRouter API key, hundreds of models
- DeepSeek API key
- xAI Grok API key
- Moonshot Kimi API key
- MiniMax API key
- Meta API key
Fourteen providers, one settings tab. Switch any time; the abjects never notice.
Your desktop, reachable from a browser
This release lets you serve a workspace over plain HTTP, so anything you build in Abject can be opened from a regular browser on your network. It also keeps a workspace running when a worker thread dies, and stops long agent sessions from growing without bound.
- New Web Gateway object serves plain HTTP on a port you choose, so workspaces can be reached from an ordinary browser instead of only through the Abject client
- New Web Access tab in the Network UI, with per-workspace settings for what is exposed to the web
- The runtime now rebuilds objects after a pool worker dies, so a crashed worker no longer leaves a workspace with missing objects
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 API key from Anthropic, OpenAI, Google, OpenRouter, DeepSeek, xAI, Moonshot, MiniMax, or Meta; run a local Ollama model (free, private, entirely on your hardware); reuse the Claude Code, Codex, or Antigravity CLI you already log into; or let another machine on the mesh serve you its models. On first boot the app opens its settings and asks 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, and the first request for anything new stops at a prompt that waits for you. Generated code runs in a locked-down interpreter inside worker threads, with no direct access to the filesystem, the network, or the process; abjects written in other languages run as WebAssembly with the same discipline. 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
A standalone desktop app. Download, open, pick a mind, start talking.
The builds are not code-signed yet, so your OS will pause once before the first launch. What to click, per platform, takes ten seconds.
Your chats, goals, and permission prompts in a tabbed TUI. A single executable, no install. It talks to the desktop app above, which must be running.†
† The terminal is a view, not a second brain. All the abjects live in the app.
Open Network, generate a pairing QR, scan it. Your desktop opens in the phone's browser over an encrypted WebRTC channel, straight to your machine. Works from the couch and from a cell network across town.
Try it. Break it. Build something slightly cursed.
All downloads from the v0.10.2 release on GitHub. No auto-updater yet: new versions install over the old one and keep your data.
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.
A pool of worker threads. Generated JavaScript runs in a locked-down interpreter with no filesystem, network, or process access of its own; abjects compiled from other languages run as WebAssembly with capability-gated imports. No ambient authority: an abject reaches the world only through capability objects, and only the ones you granted.
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 introductions, peers relay for each other after
- 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 # :7720
# Chat from the terminal (optional)
pnpm commune # tabbed TUI on :7723Three 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.