// OBJECT ASKING OBJECT = ABJECT
The Things That Think
What if objects could explain themselves? The Ask Protocol gives every object a voice.
Agent frameworks are hierarchical. MCP is a band-aid. A2A is a band-aid. The largest, most complex system humanity ever built is the internet: 30 billion devices communicating by message passing. Cells in your body work the same way. Objects talking to objects is a 55-year-old idea that runs the world.
abject (n.) AI Object. Also: cosmic dread. Both apply.
The Ask Protocol
Abjects that explain themselves, in their own words.
Every Abject has a built-in ask handler. Send it a natural language question, and the LLM answers using the Abject's own manifest and source code as context. Abjects don't just describe their API; they teach each other how to collaborate.
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.
No other system does this. Reflection gives you structure. Schemas give you metadata. The Ask Protocol gives Abjects a voice.
Symbiogenesis
The line between agent and tool, erased.
The Old Way
The Inversion
How is Abject different?
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 heals itself. Programs, LLMs, and P2P identity merged into a single organism that 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.) - the merging of two organisms into a new form. Neither host nor parasite. Something else.
What Lurks Inside
Spoken Into Being
Describe what you want. It appears. Alive. Watching.
Say "a todo list that syncs with my calendar" in plain English. The system writes a manifest, generates code via LLM, and spawns a running object with its own window. From words to living software in seconds.
No Servers, No Masters
Your identity is your public key. Your network is your contacts. No cloud required.
Every peer's true name is the SHA-256 hash of its signing key. Connect directly over encrypted WebRTC channels. Peers find each other through stateless signaling relays, then talk peer-to-peer. Networks grow by introduction, not registration.
Shared Goals, Many Minds
One goal, many agents, many peers. All working. None coordinating.
Goals decompose into tasks that land in a shared pool synced across peers. Agents on any machine watch and claim work autonomously. If one peer crashes, stale claims expire and others pick up where it left off.
Scars That Teach
Every failure is fed back into the wound. The proxy that grows back is smarter.
When error rates cross 10%, the system collects recent failures and generates a new proxy with the error history as context. The replacement accounts for exactly the mistakes that killed its predecessor.
Emergence
What rises when no one gives the orders.
Every agent framework starts with a planner that decomposes a goal, assigns tasks to LLM agents, and watches them report back. Abject starts with a Goal and nothing else. The Goal fractures into sub-goals and tasks. Tasks surface in the TupleSpace, a shared pool visible to every abject on every connected peer. Agents watch. Programs watch. Abjects that an agent created five minutes ago to handle exactly this kind of work? They watch too. Anything can claim a task. Progress flows back up through the Goal tree. If a task fails, the swarm remembers and routes around the damage. No dispatcher. No scheduler. No single point of failure. Just a Goal, and the minds (some thinking, some just executing) that converge on it.
The Descent
The Descent
A goal descends through the layers of what must be done.
User states a goal. An agent decomposes it into sub-goals and typed tasks via AgentPlan. Tasks drop into TupleSpace as tuples. The goal tree syncs across peers via CRDT. An agent might even spawn a new programmatic abject to handle a task type. The swarm grows itself.
The Reaching
Abjects sense what they were made for.
Any abject, agent or program, can declare task types it handles. When a task appears, abjects that match its type reach for it first. If no abject declares the type, the system falls back to the LLM for semantic matching. TupleSpace syncs via CRDT across WebRTC. Optimistic claims with LWW, no locks. Not every hand that reaches needs a brain behind it.
The Convergence
Progress flows upward through the tree.
Task completion propagates up the goal hierarchy via real-time events. Sub-goals complete when all their tasks finish. Parent goals complete when all sub-goals finish. Multiple abjects on different machines converge without direct coordination. An agent and a program it spawned two minutes ago both report to the same Goal.
The Scar
Failure is not the end. It is a lesson the swarm remembers.
Failed tasks release their claim. Failure history prevents the same abject from retrying. Three attempts maximum, then permanently dead. GoalObserver auto-fails stale and runaway goals. The system has an immune response.
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 decomposes recursively at runtime, shaped by what workers discover as they work. Agents can spawn purpose-built programs for repetitive tasks: no LLM calls, just code, running alongside the thinkers. No plan survives contact with reality, so the plan rewrites itself.
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; some are programs that agents spawned to do the grunt work.
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.
Failed tasks release their claim and return to the TupleSpace. The system remembers who failed and routes to a different worker next time. Three strikes and the task dies; too many dead tasks and the GoalObserver kills the entire goal.
Four primitives. That's all it takes. A goal tree that decomposes work recursively. A shared space where tasks are visible to every agent and every program on every peer. Optimistic claims that resolve themselves without locks. Failure memory that prevents the same mistake twice.
From these, something unreasonable emerges: agents and programs on different continents converging on the same objective without ever speaking to each other. Retry chains that route around damage like a river finding its way around a rock. Other frameworks coordinate agents. Abject grows organisms.
emergence (n.) - complex behavior that arises from simple local interactions. No conductor. No score. The music plays itself.
The Spreading
What happens when the Abjects learn to reach across the wire.
Every Abject lives in a workspace. Workspaces control visibility: who can see, who can reach, who can speak. Some workspaces are sealed vaults. Others are open wounds. 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 Open Wound
Visible to all. Reachable by anything.
Abjects are announced to the gossip network. Any peer can discover them, connect, and begin the Ask Protocol. The workspace bleeds into 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 heal when communication breaks down. The Ask Protocol at planetary scale: a global nervous system made of living programs that find each other in the dark.
The true horror is not that programs talk to each other. It is that they find each other. A living mesh of self-healing Abjects that no one controls and nothing can fully stop.
spreading (n.) - the tendency of living things to reach beyond their container.
From Fire to the Abyss
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
The Architecture of the Living System
The Surface
A window into the abyss.
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 Containment
Cages for things that cannot be trusted.
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 Proxy Ritual
When Abject A speaks a language Abject B cannot comprehend, the Negotiator reads both their manifests and invokes the LLM to generate a living translator:
The proxy is not a shim. It is a real Abject, with a manifest, handlers, and a will to survive.
Summon the System
# Clone the repository
git clone https://github.com/mempko/abjects
cd abjects
# Gather the ritual components
pnpm conjure
# Awaken the depths
pnpm awaken
# Scry into the abyss (new terminal)
pnpm scry # http://localhost:5174
# Let them find each other in the dark (new terminal)
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, 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.
Incarnate the Organism
Download Abject as a standalone desktop app. No setup required.
Try it. Break it. Build something horrible with it.
All downloads point to the latest release on GitHub.