How the Organism Grew

Every LLM Call, Accounted For

Abject now keeps a ledger of every LLM call it makes, including what each one cost. The Eye shows the running record, so you can see where your tokens and money actually go.

Highlights

• An LLM call ledger records each request your objects make, with per-call cost
• The Eye displays the ledger, giving you a live view of spending across the system

Bulk Results Off The Critical Path

Large agent results now travel on the payload channel and stay where they are, so generated code can work with them without pulling everything into memory first. Connection health is also judged on recent traffic instead of a lifetime tally.

Highlights

• Every agent's bulk results now go out on the payload channel, keeping big result sets out of the regular message path
• Generated code can operate directly on held payloads instead of paging them in, which avoids copying large data just to read part of it

Fixes

• Connection health is now measured over a recent window of messages; a long history of successful traffic can no longer mask a connection that has broken

Big results stay whole, agents stay honest

Agents can now work with large results without losing anything: long observations, extracts, and action outputs are held intact and read in chunks instead of being truncated. Prompts are cached across tasks, and the server and terminal client recover cleanly instead of hanging.

Highlights

• Large results are kept whole and read in chunks: observations, action results, and extracts no longer get cut off partway through
• Producers now declare when a result is bulk, rather than the system guessing from its size; large extracts are handed over intact and every path shares one size threshold
• Agent prompts are split into a stable, cacheable prefix and a per-task tail, with prefix caching enabled on the routes that need it: less repeated work per task
• Agent predictions are recorded and the misses reviewed, so you can see where an agent expected one thing and got another
• The server survives a wedged shutdown instead of holding its ports, so a restart works without hunting down a stuck process

Fixes

• An agent's narration is now treated as the result it forgot to fill in, instead of the step coming back empty
• Markdown answers whose newlines were not escaped are accepted rather than rejected
• Ctrl-C now exits the terminal client while it is reconnecting

Pictures in the Terminal

The terminal client can now show inline images as ANSI art, so you no longer have to switch to the desktop to see what an object sent you. This release also fixes window capture and stops two runaway loops that wasted work in the background.

Highlights

• Inline images now render as ANSI art in the terminal client (pnpm commune), so pictures in a chat show up in place instead of as an unreadable reference

Fixes

• Window capture works again
• Repeated handler errors are throttled instead of flooding the logs
• Stopped the reparse loop from burning steps it did not need

Richer Markdown on the Canvas

A small release that rounds out markdown rendering in canvas windows: documents with deep heading structure and numbered lists now display properly instead of falling back to plain text.

Highlights

• Canvas markdown now renders h4 through h6 headings and ordered (numbered) lists, so agent output and notes with deeper structure display correctly.

Fixes

• Release packaging: asset upload now handles the two-root artifact layout, so downloadable builds attach to releases reliably.

Commune: Abject from the Terminal

This release brings Abject to the terminal. Commune is a new text client that connects to your running peer, ships as a single-file executable, and lets you talk to your objects from anywhere a shell runs. Conversations also got smoother: you can keep typing while a goal is in progress.

Highlights

• Commune, a new terminal client for Abject: chat with your workspaces over a dedicated CliServer gateway (port 7723) using the same auth tokens as the web client, with tmux-friendly Alt-key bindings
• Commune is packaged as a single-file executable in releases, so you can drop it on any machine without installing Node or cloning the repo
• Type while agents work: messages sent during a running goal are queued as interjections and folded into the plan instead of being lost or interrupting mid-task

Sharper Questions, Easier Sharing

A small release that makes agent-to-object conversations more precise and adds a quick way to share Abject from the website. When an agent asks an object what it can do, the answer is now scoped to that specific object, so agents get cleaner guidance and fewer irrelevant suggestions.

Highlights

• The ask protocol is now scoped to the object being asked: objects describe only their own abilities instead of surfacing system-wide guidance, which keeps agent decisions grounded in what the target object can actually do
• The website has a new /links page with QR codes, making it easy to share Abject from a phone or point someone to it in person

Touch comes to the desktop

This release makes Abject usable on tablets: the 3D desktop now responds properly to touch, and the on-screen keyboard works on iPads and other tablets. It also fixes a bug where one failed handler could stall an agent permanently.

Highlights

• Touch input now works on the 3D desktop layout: you can drag windows, interact with 3D objects, and type, all by touch
• The virtual keyboard now appears on tablets, not just phones, and comes up as part of the gesture that focuses a window
• iPad keyboard input is more reliable; backspace now registers correctly
• Tablets in desktop mode get the full desktop layout instead of the phone layout, and pinch-to-zoom no longer interferes with it
• Added an input diagnostics page to help troubleshoot touch and keyboard issues on your device

Fixes

• A handler that failed mid-task could wedge an agent's queue forever; agents now recover and move on to the next task

Per-Object Shell Permissions

Objects that want to run shell commands now ask for permission individually, so you can grant one object access without opening the door for everything else. The permission dialog has been redesigned to make what you are approving clearer.

Highlights

• Shell access is now granted per object: each object carries its own permission rather than sharing a single global setting
• Redesigned permission dialog: clearer presentation of which object is asking and what it wants to do

Skill credentials that stick

Skills and MCP servers now keep the credentials you give them, and when an MCP server fails to start you see why instead of a silent no-op. Also adds a /theory page explaining the ideas behind Abject.

Highlights

• New /theory page on abject.world: the thinking behind Abject, why objects (not agents) and why local-first
• MCP server startup failures now surface the actual error (captured server output) instead of failing quietly
• Links to abject.world now show a proper preview card when shared

Fixes

• Credentials entered for a skill were silently dropped instead of being saved to the skill's config
• Enabling a skill backed by an MCP server reported success even when the server never started

3D on Your Phone, For Real

This release makes the 3D desktop work reliably on mobile GPUs. Android devices (especially Adreno chips) that previously showed a blank screen now render the full workspace.

Highlights

• Reworked the 3D mesh shaders to follow strict mobile GPU rules (matched precision, constant loop bounds), so windows and scenes render correctly on Android phones and tablets
• If a device's GPU still can't compile the shaders, the renderer now degrades gracefully to a working 2D desktop instead of a blank page

Fixes

• Blank desktop on mobile Chrome caused by shader compilation failures on Adreno and similar mobile GPUs

Holding the Scene Together

A small stability release focused on the 3D desktop: reconnecting to a session now rebuilds the scene correctly, windows keep their depth to themselves, and the renderer survives mobile Chrome's quirks.

Highlights

• More reliable 3D rendering on mobile Chrome: the WebGL2 renderer is hardened so the desktop no longer goes blank
• Cleaner session reconnects: the 3D scene now rebuilds fully, with removed objects cleaned up in cascade and animations retained and replayed

Fixes

• Reconnecting no longer leaves stale objects or frozen animations in the 3D scene
• Each window's 3D depth is now isolated, so a window behind another can no longer punch through it visually
• Mobile Chrome no longer blanks the screen due to WebGL2 renderer failures

Private workspaces stay private

Shared state in a private workspace now syncs only to peers you have explicitly whitelisted. If you use private workspaces with peers connected, this closes a path where state could reach peers you had not approved.

Highlights

• Private-workspace SharedState sync is now gated to whitelisted peers: peers outside the whitelist no longer receive updates

Storage That Keeps Up

Saving data no longer rewrites your whole store on every change, so workspaces stay responsive as they grow. Existing data migrates automatically the first time you start this version.

Highlights

• Storage now uses SQLite for per-key writes instead of rewriting the entire JSON file each time; this removes the multi-second stalls that showed up once a store got large
• Your existing JSON store is migrated to SQLite once, on first boot; no action needed and the storage interface is unchanged

Fixes

• Fixed workspace freezes caused by frequent saves scaling with total store size rather than the amount of data actually changed

Chats That Wake When You Need Them

Conversations now load only when you open them, so workspaces with a lot of chat history start faster and stay responsive under load. Agents also think at a level matched to what they are actually doing, which cuts unnecessary work on routine steps.

Highlights

• Chats rehydrate lazily: a workspace no longer spawns every past conversation at boot, it loads a chat when you open it
• The conversation list stays usable under heavy load instead of stalling while history catches up
• Agents pick their reasoning tier based on the state they are in, so simple steps stay quick and harder ones get more thought
• All agents now share one system primer, giving them consistent grounding about the system they run in

Fixes

• Fixed the goal-event flood from many simultaneously live chats that could freeze rendering in busy workspaces

Chat that stays grounded, and gets out of the way

Chat now moves faster on simple requests and is more honest about what it actually did. Single-step asks skip the planning overhead, and replies can no longer claim work that never happened.

Highlights

• Fast path for single-step requests: simple asks skip full planning and dispatch directly, cutting most of the back-and-forth before anything happens
• Chat replies are grounded in real work: a reply cannot claim an action was taken unless there is a goal behind it

Fixes

• Chat no longer reports work as done when no action was actually dispatched

Hidden Means Hidden

A small maintenance release for the canvas compositor: hiding a layer now truly hides it. If a window or widget sets itself invisible, nothing from it lingers on screen.

Fixes

• Canvas layers now honor style.visible when hiding, so content marked invisible no longer keeps rendering after its window is hidden

A Pattern Language Takes Root

Your KnowledgeBase can now grow a generative pattern language: reusable patterns that link to each other, expand through weave, and show up on a language map. Alongside that, resizing windows full of markdown is much faster.

Highlights

• The KnowledgeBase gains a generative pattern language: agents can save and refine patterns, weave expands linked patterns into context (and flags dangling links), and a language map shows how your patterns connect.

Fixes

• Resizing markdown-heavy windows (like long chats) is now fast; text layout no longer recomputes from scratch on every mouse movement.

Windows That Hold Together

This release makes tilted windows behave like real solid objects on the desktop. Rotate a window and everything about it moves as one piece: the frame, its content, and where your clicks land.

Highlights

• Tilted windows now render, clip, and respond to picking as a single rigid object; content stays inside the frame and clicks land exactly where they appear, at any angle

Fixes

• Content no longer bleeds outside the frame of a rotated window
• Clicks on tilted windows no longer miss or hit the wrong spot because picking used the flat layout instead of the rendered angle

Version History, Self-Healing Scrums, Warmer Caches

This release makes long-running work safer to trust: scriptable abjects keep a source history you can restore from, goals can be paused or stopped mid-flight, and stalled scrums recover on their own. Under the hood, smarter LLM plumbing keeps prompt caches warm and routes reasoning effort per model tier.

Highlights

• Scriptable abjects now keep a version history of their source; open the editor's History panel to browse past versions and restore any of them
• You can pause or stop a running goal at any time, and scrums self-heal when their work stalls instead of hanging forever
• Prompt-cache keepalive: the LLM service keeps warm prompt caches alive with a content-addressed registry, reducing latency and token cost on repeated turns
• Reasoning effort is now routed per model tier, so heavier thinking goes where it helps and cheap calls stay cheap
• Clearer diagnostics when a model truncates its output or refuses a request, so failures explain themselves instead of failing silently

Fixes

• Scrums that lost an agent mid-run previously stalled indefinitely; they now detect the failure and recover automatically

Cloning, clearer errors, and sturdier plumbing

This release lets agents clone existing objects as a starting point for new ones, and makes the platform more honest when things go wrong: clearer error messages, streaming that recovers from stalled LLM providers, and routing failures that surface immediately instead of silently misbehaving.

Highlights

• Agents can now clone an existing object to create a new one, preserving the authoring invariant so cloned objects remain editable and self-consistent
• The two error messages agents run into most often now explain what went wrong and what to do about it, so agents can self-correct instead of retrying blindly
• Streaming from OpenAI-compatible providers now detects empty and hung completions and fails cleanly instead of leaving conversations stuck

Fixes

• Fixed a desync in worker-thread routing that could send messages to the wrong worker; the system now fails fast if routing state ever diverges again
• Reading and updating an object's source or manifest now falls back to the secondary registry, so these operations work for objects that only the fallback knows about

v0.8.18

Release v0.8.18.

Highlights

• WebSocket server heartbeat: ping every 30s and terminate connections that miss a pong

Windows Stay In Their Frames

A single fix for 3D windows: mouse clicks now stop at the edge of the window they belong to, so one window no longer swallows input meant for the rest of the workspace.

Highlights

• Mesh picking in 3D scenes is clipped to its window's bounds, so clicking outside a window reaches whatever is actually there

Fixes

• One window's 3D content captured picking across the entire workspace, leaving other windows and the desktop unclickable

Scenes that render whole, writes that stay calm

This release fixes 3D scenes that were rendering only their front half, unifies 2D canvas and 3D scene drawing into one z-sliced compositor, and stops runaway saves from stalling a workspace. Objects that draw, persist, or get discovered should all behave more predictably.

Highlights

• Canvas layers are now scene nodes: 2D and 3D content interleave by depth through a single unified draw channel, so a canvas widget can sit behind or in front of 3D geometry
• 3D scenes render fully again: a leaked DEPTH_TEST state was culling everything behind the window, so scenes only showed their front half
• Persistence no longer floods the bus: saveData calls are coalesced, with a flush on shutdown so nothing is lost on the way out
• Registry.discover rejects free-text queries rather than quietly dumping the whole catalog back at the caller
• Light intensities in photometric units (lux, lumens) are rejected up front instead of washing every mesh to pure white
• Newly spawned objects get a registration grace window: messages addressed to an id still in flight are parked rather than dropped
• ObjectCreator spends fewer LLM turns on validation the machine can do for free, so object creation is faster and cheaper
• The changelog keeps every release instead of collapsing entries that share a minor version

Fixes

• Instanced scene colours were being squared, making them render darker than specified
• The scene 'animate' property was silently dropped
• Canvas layers were attached to the wrong camera

Smoother under the hood

This release moves the UI shell into a worker thread so the desktop stays responsive, and fixes three everyday annoyances: wasted CPU while idle, drafts disappearing, and asks that quietly died. There is also a new changelog on the site so you can follow what changes between releases.

Highlights

• The UI shell now runs in a worker thread instead of the main thread, keeping the desktop responsive even when objects are busy; the seams between threads were hardened along the way
• A changelog page on abject.world now tracks what changes in each release

Fixes

• Idle sessions no longer burn CPU when nothing is happening
• Drafts are no longer lost in progress
• Asks no longer die silently before being answered

New blood: WASM, a binary wire, and a learning loop

The 0.8 line let Abjects be written in any language, made every remote byte binary, and started teaching the agents to learn from their own work. It also brought the biggest Settings and authoring-loop overhaul yet.

Highlights

• WASM Abject hosting: ABI v1, a C++ SDK, pnpm forge packaging, and a native C++ KnowledgeBase shipping as a bundled system package; Abjects can now be written in any language that compiles to WebAssembly
• Binary wire protocol for all remote traffic, with interning, frame acknowledgment flow control, and content-addressed image blobs
• Connective tissue for the object system: triggers, SQL-backed collections, full-text knowledge search, streams, audio, speech, and video, and prototype cloning
• A learning loop: TaskReviewer grades finished work, knowledge entries carry provenance and usefulness, and every agent can recall and remember
• Vision awareness end to end: per-model vision capability tracking, a configurable vision-fallback model, and screenshots that verifiers can actually judge, including real 3D scene content
• Web Viewer human takeover: pass captchas and log in yourself, then hand the page back to the agent
• Meta Model API provider (Muse Spark 1.1), an explicit Code tier for code generation, and savable tier presets with built-ins derived from every provider's defaults
• Authoring loops that finish: progress-aware step-budget extensions, draft persistence across task retries, and advisory (non-blocking) semantic review
• Settings redesigned: a card-based AI tab in setup order, category sub-tabs for Permissions, and a dedicated Skills & MCP tab
• UI Abjects are now authored with MVC (in the original Smalltalk sense), DCI, and Design by Contract

Fixes

• Peer-transport wire codec desync after reconnects, and out-of-order inbound handling
• Agent orchestration losses: dropped goal completions, false-positive verifications, and capability polls timing out behind busy agents
• Zero-height self-sizing widgets being culled before they could measure (invisible chat goal trees)
• Long model names bleeding out of Settings dropdowns; window screenshots missing 3D scene content
• The scene-op error hint omitting 'animate', teaching agents a valid op was unsupported

Self-repair, taught properly

A craftsmanship release: the object-creation loop learned to edit code structurally instead of by guesswork, every window got a live method inspector, and P2P grew a TURN relay so peers reach each other from anywhere.

Highlights

• Structure-aware editing: ObjectCreator reads drafts by handler, replaces whole methods by name, and parses handler maps with a real parser instead of regexes
• MethodInspector: every window's ? button opens a live, two-pane inspector for the object that owns it
• TURN relay fallback so WebRTC connects across symmetric NAT and cell networks
• Host MCP import: MCP servers configured in mcporter or OpenClaw appear as skills automatically
• Styled containers and rich list cards across the built-in apps; one shared markdown renderer everywhere, including a canvas markdown draw command
• Image paste into chat, and canvases that accept pasted or dropped images
• Theme $tokens usable directly in canvas draw commands, plus a 'designing apps that look good' guide agents actually receive
• User-profile facts injected into every agent's context; per-surface and per-step model tiering to spend smart-model tokens only where they matter

Fixes

• P2P reconnection replacing stale transports, and trickled ICE candidates dropped mid-negotiation
• Window resize events never reaching window owners; wrong window closing from ScriptableAbjects
• Registry re-registration leaking uniquified names and flickering the sidebar
• Runaway retry loops in object creation; oscillation false-positives on legitimate edits
• A 30-second hang reopening windows caused by speculative request forwarding to peers

The desktop grows a third dimension

The compositor was rebuilt on WebGL2: every window is now a slab in a native 3D scene, and objects can attach real lit geometry to their windows. The same release brought workspace files, a mobile gesture UI, and a unified sidebar.

Highlights

• Native 3D desktop: a WebGL2 compositor with a retained scene vocabulary of meshes, PBR materials, lights, fog, per-vertex colors, textures, instancing, bloom, and shadow maps
• Arbitrary, dynamically-updatable polygonal meshes for deformable surfaces like water and terrain
• Workspace files: disk-backed FileSystem, an upload pipeline, and a File Manager
• Mobile: a WebOS-style gesture UI with a card overview
• One collapsible sidebar dock replacing three separate rails, with object icons and command-palette keyboard navigation
• The recipientGone protocol: widgets whose owner dies now clean themselves up instead of haunting the message bus
• Canvas draw commands validate loudly and document their whole vocabulary in the error

Fixes

• Corrupted snapshots dropped on restore instead of wedging boot; manifests validated on save
• Fog made scene-relative, fixing the flat-blue fish tank
• Layout children detached from window full-content sizing at any nesting depth
• KnowledgeBase pollution from routine chatter, and lost Chat fact capture

A face, a phone, and a scrum team

Abject got its visual identity (themes, icons, motion, a command palette) and its agents got a proper team structure: a dedicated ScrumMaster plans work across specialists instead of every agent splitting tasks itself. Your phone joined too.

Highlights

• Eight built-in themes with an Appearance tab and user-registered themes; Arcane Grimoire became the default look
• Design tokens, vector icons, motion, a command palette, notifications, and full text-editing parity across widgets
• Scrum-shaped orchestration: a ScrumMaster Abject runs planning rounds, dispatches to specialist agents, and reviews outcomes
• Remote UI access: pair a phone by QR code and use your desktop's objects from anywhere, over P2P
• Claude and Codex CLI backends alongside API providers, with self-describing provider metadata driving the Settings UI
• Objects carry their own data: this.data persists, travels with clones, and survives hot reloads
• Per-workspace persistent web-browsing profiles, screenshots delivered inline into chat, and one-shot schedules
• The site grew an About page, an Examples section, and real search-engine manners (sitemap, OG cards)

Fixes

• CLI subprocess idle timeouts that reset on token activity, and bounded retries with backoff across all providers
• Streaming keepalives that survive the whole stream, not just its start
• Agent decompose races and refusal-prone skill prompts
• QR pairing scan reliability and pairing UI stability

A bigger toolbox

Six new LLM providers, a skills catalog with a secrets vault, and an ObjectCreator rebuilt on the shared agent runtime with surgical SEARCH/REPLACE editing.

Highlights

• OpenRouter, DeepSeek, Grok, Gemini, Kimi, and MiniMax joined Anthropic, OpenAI, and Ollama as providers
• ClawHub and MCP registry catalogs for discovering skills, with a secrets vault and OAuth flows for the ones that need accounts
• ObjectCreator rewritten on AgentAbject, editing existing objects with SEARCH/REPLACE diffs instead of full rewrites
• A scrollable workspace with pan gestures and scrollbars; the desktop stopped ending at the screen edge
• Multiple chat conversations per workspace, and a per-object Console for debugging
• The background renders on a budget: cached glow sprites, throttled idle framerates, pausing when hidden

Fixes

• Dispatch payloads surviving free-form LLM text; event delivery and progress propagation hardening
• Recurring work routed to the Scheduler primitive instead of spawning agent after agent
• Settings window sized so the AI tab actually fits

Doors to the outside world

MCP arrived: Abjects can now speak to external tool servers as easily as to each other. Inside, agents learned to report progress honestly, retry with memory of their failures, and stop timing out on long work.

Highlights

• MCP bridge: connect external MCP servers over stdio JSON-RPC, with tool-input validation and parameter schemas surfaced to agents
• Organisms: compose cooperating objects into one creature with a single public surface
• ScriptableAbject handlers run sandboxed, with scope guidance in every ask answer
• Progress-based timeouts (long work stays alive as long as it reports progress) and failure history passed to retries so agents learn from mistakes
• Structured YES / PARTIAL / NO dispatch verdicts, sequential-by-default task execution, and a preference for configured tools over generic automation
• Prompt caching for Anthropic and OpenAI; Opus 4.7 as the smart tier
• Chat grew bubbles, a live goal tree, and a streaming indicator

Fixes

• P2P shared state scoped to public workspaces only; private stays private
• Data-flow truncations between agents, and duplicate schedules on add and load
• Mailbox drops surfaced loudly; signaling peer binding and WASM target validation hardened

Agents that know their limits

The agent system grew up: work routes through a shared TupleSpace, agents answer for themselves whether they can do a task, and a permissions system puts the user in charge of what they touch.

Highlights

• Per-tier LLM routing: smart, balanced, and fast tiers each pick their own provider and model
• ObjectAgent and TupleSpace routing: all agent work flows through one dispatchable space
• Ask-based self-selection: the dispatcher polls agents about a task and routes to whoever credibly says yes
• A permissions system: a Settings tab, runtime prompts for unlisted paths and commands, and per-skill trust
• KnowledgeBase and KnowledgeBrowser: durable cross-session memory with a UI
• Screenshot capability with UI input injection, so agents can see and verify what they build
• WebAgent upgraded to accessibility-tree observation; goal-oriented Chat with task dependencies and reflection

Fixes

• OpenAI provider using max_completion_tokens and surfacing error bodies
• Title-bar stacking from a stale canvas transform; markdown links in non-wrapping labels
• Electron builds bundling the Playwright headless shell, and the app actually exiting when its window closes

First light

The founding release: a desktop where everything (the registry, the factory, the windows, the chat) is an object with a mailbox, and new objects are spoken into existence.

Highlights

• The Abject runtime: message passing, mailboxes, a Registry, a Factory, and Design by Contract everywhere
• Speak objects into existence: a three-phase LLM pipeline drafts a manifest, writes the code, and deploys a live object
• The ask protocol: every object answers plain-English questions about what it is and how to use it
• An X11-style windowing system built from object widgets: windows, layouts, taskbar, themes, and a canvas
• Chat, JobManager, and the first agent workflows; multi-workspace support with worker-thread parallelism
• P2P foundations: cryptographic identity, a signaling server, WebRTC transports, and workspace sharing
• Persistent storage so objects survive restarts, plus provider-aware LLM settings with Ollama support
• abject.world itself went live

Fixes

• Deadlocks, re-entrant message handling, and window destroy races: the runtime's first hard lessons
• Timeout cascades during long LLM operations
• Ctrl+click window dragging and same-z-index raise ordering