// WHY ABJECT
The Long Answer
The short answer fits on the front page: an actor system where every actor can be interviewed. This page is the comparison in full, for anyone who has already built on the frameworks named below and wants to know exactly where the line is drawn.
// 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. Coding agents spawn subagents in fresh contexts, one level deep by design. 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.
Convinced, or at least curious?