Harness atlas

The result that flipped the field: a thin ReAct loop with files, bash, grep, CLAUDE.md memory, and compaction beat elaborate multi-agent graphs on real software work.

Mechanism

Single-threaded tool loop, permissioned diffs, context compaction, project memory file.

AGI gap

Working memory (compaction), retrieval (CLAUDE.md), reasoning (the loop itself).

Lesson for Aether

Harness quality over graph topology. Aether's chamber is this shape: one loop, many layers as tools.

The batteries-included Claude Code analog on LangGraph: planning tool, virtual filesystem, sub-agents, summarization, skills.

Mechanism

Middleware on an explicit graph state. Harness engineering as the 2026 lever.

AGI gap

Planning, WM (virtual FS), procedural skills.

Lesson for Aether

Aether's skill library and planner are the portable version of this idea.

Production default for long-horizon work: explicit state, checkpoints, replay, human-in-the-loop. Ranked first for durable tasks in 2026 surveys.

Mechanism

Graph + reducer + checkpointer. Recovery is a first-class primitive.

AGI gap

Horizon / autonomy (METR), not a CHC faculty.

Lesson for Aether

Aether persists traces and memories so a later turn can resume. Full graph recovery is the next rung.

Self-hostable autonomous engineer. Plans a dependency graph, then fans work out to sub-agents in a sandbox.

Mechanism

Planner → DAG of tasks → sandboxed execution.

AGI gap

Planning, tools, speed of software labor.

Lesson for Aether

Hierarchy matters once a task has real dependencies. Aether's planner is the single-agent form.

Defined the Agent-Computer Interface. mini-swe-agent later showed ~100 lines can still clear 74%+ on SWE-bench Verified.

Mechanism

Constrained edit/command interface; issue in, patch out.

AGI gap

Reasoning on software environments; WM via editor state.

Lesson for Aether

The interface is the intelligence. Aether's tools are a small ACI: memory, calc, world, skills.

Treats context as RAM and a vector/archival store as disk. The agent pages memories in and out.

Mechanism

Tiered memory with explicit page-in/page-out tools.

AGI gap

MS and MR — the CHC zeros.

Lesson for Aether

This is the load-bearing prosthetic. Aether's episodic/semantic stores are a Letta-shaped design.

Drop-in memory layer extracting, consolidating, and retrieving user facts across sessions.

Mechanism

Extraction + dedup + retrieval API.

AGI gap

MS / MR for personalization.

Lesson for Aether

Memory must be extracted, not merely logged. Aether writes memories as a first-class tool, not a transcript dump.

Personal agent that 'grows with you' — always-on, self-improving, local-leaning.

Mechanism

Persistent identity + skill accumulation over calendar time.

AGI gap

MS as a life, not a session. Goals.

Lesson for Aether

Proto-AGI has to be the same someone tomorrow. Aether binds memory to an account.

Role-playing multi-agent crews. Fastest path to a researcher/writer/critic split.

Mechanism

Role, goal, backstory, sequential or hierarchical process.

AGI gap

Reasoning via specialized perspectives (debate layer).

Lesson for Aether

Aether's debate layer is a two-voice crew without the orchestration tax.

Conversational multi-agent, then folded into MAF 1.0 with Semantic Kernel's enterprise runtime. AutoGen itself is in maintenance.

Mechanism

Agent chat, code sandbox, handoffs.

AGI gap

Reasoning, tools, recovery.

Lesson for Aether

The industry moved from conversation graphs to runtimes. Aether is a runtime with one occupant.

Managed agents plus a coding product collapsing into ChatGPT. Computer-use as embodiment-lite.

Mechanism

Hosted tools, computer use, handoff patterns.

AGI gap

Vision (screens), tools, economic work.

Lesson for Aether

Embodiment in this era is a pointer and a shell. Aether stays text-native and admits the vision gap.

Agent Development Kit: orchestrated agents with Gemini, first-class tools and evaluation.

Mechanism

Declarative agents + tool surface + eval hooks.

AGI gap

Evaluation-driven generality.

Lesson for Aether

A harness without a battery is a chatbot. Aether ships the battery next to the loop.

The terminal-coding cluster. Plan-then-act (Cline), repo maps (Aider), local-first (Goose/Block), CLI-native (OpenCode, Crush, Gemini CLI).

Mechanism

Repo as environment. Diffs as the write primitive. User approval as a value.

AGI gap

Tools, WM, horizon on a codebase.

Lesson for Aether

Most 'agent' products are ACIs over git. Aether is an ACI over a mind: memory, goals, skills, world.

Open-ended Minecraft agent that writes, stores, and reuses skills. Curriculum from automatic novelty.

Mechanism

Skill library + iterative prompting + embodied environment.

AGI gap

Procedural memory, adaptation, Chollet-style skill acquisition in one world.

Lesson for Aether

Aether's skill store is Voyager without the game. Skills must be reused, not just saved.

The three primitive lattices: interleave reason+act; verbal self-critique into the next try; search a tree of plans.

Mechanism

Prompt-level control flow. No new weights.

AGI gap

On-the-spot reasoning.

Lesson for Aether

Aether implements all three as toggleable layers. That is the experiment: how much of R is search.

Model Context Protocol standardizes tools. Skills package procedures the agent can load. Superpowers-style methodologies spread the same idea.

Mechanism

Typed tools + on-demand playbooks.

AGI gap

Tools and procedural knowledge.

Lesson for Aether

Aether's tools and skill library are a private MCP. The protocol is how lattices compose.

The first public 'loop until the goal is done' agents. Recursion without recovery. Historically important, operationally fragile.

Mechanism

Goal → tasks → execute → new tasks.

AGI gap

Agency / goals. Demonstrated the failure mode of unconstrained loops.

Lesson for Aether

Aether keeps a goal stack and a budget (one user turn, bounded tool rounds). Horizon without a halt is a bill.

Compile prompts and tool use against a metric. Treat the lattice as a program to optimize.

Mechanism

Signatures, modules, teleprompters.

AGI gap

Adaptation — learning the scaffold itself.

Lesson for Aether

Aether's battery is the metric. We do not yet compile the layers; that is the obvious next experiment.

Always-on personal agents (OpenClaw), long-horizon research SuperAgents (ByteDance DeerFlow on LangGraph), local-first memory companions (OpenHuman).

Mechanism

Presence + memory + research tools, with different discipline/safety postures.

AGI gap

MS over calendar time; METR horizon on research.

Lesson for Aether

Proto-AGI is lived-with, not demoed. Aether's login exists so the lattice can be a companion, not a pastebin.