OB1

Open Brain + OpenClaw architecture

How the pieces fit together — the runtime, the swappable brains, the user-owned memory, and why it matters

Nate's core thesis: OpenClaw matured from a viral agent demo into a real runtime in April 2026. The model layer underneath got contested (Anthropic restricted, OpenAI opened up, Google went open-source). Once the runtime can swap brains, memory becomes the strategic layer. If you own the memory, you own the workflow. If the memory lives inside one brain, you're locked in. OB1 is the user-owned answer.

Live in your stack

Contested / swappable

Available via API

Future / not wired yet

Layer 1 — Where you are

Human + channels

Human layer

You (final authority)

The human reviews, confirms, rejects. Channels are the surfaces where work comes back — different channels, different rules.

OB1 Dashboard

PowerShell / CLI

Claude.ai

Codex

Slack

Discord

Teams

↕

Layer 2 — Where work happens

OpenClaw runtime (the action layer)

Action layer

OpenClaw

Not a chatbot wrapper. A runtime abstraction for agentic work. Has state, tools, permissions, retries, handoffs, context that survives more than one prompt. This is where the "durable work loop" lives.

Core runtime (live)

Gateway on port 18789

Plugin system (6 plugins loaded)

Profile: ob1-agent-memory

OB1 Agent Memory plugin

TaskFlow — orchestration (maturing)

Durable multi-step flows

Retry + checkpoint + recovery

Sub-agent sessions

Webhook-triggered workflows

↕

Layer 3 — The contested layer

Swappable brains (models)

Reasoning engines

Model layer

The model is not the product. It's a reasoning engine inside a larger operating loop. Swap based on the step — hard work gets frontier, cheap work gets local. Your workflow should survive model churn.

GPT-5.5 / Codex

Claude (API)

Gemini

DeepSeek

OpenRouter

Gemma 4 (local)

LM Studio / Ollama

The April 2026 model war

The model layer got contested while OpenClaw matured. Three providers made three very different moves:

Anthropic — restricted

Claude subscriptions were never designed for always-on agents. Rational but deeply unpopular. Claude becomes a premium metered component, not a cheap always-on substrate.

OpenAI — opened up

Codex made available under ChatGPT paid plans. Sam Altman explicitly called out OpenClaw availability. Opposite of Anthropic. OpenClaw distribution = OpenAI distribution.

Google — went open source

Gemma 4 under Apache 2.0. Built for agentic workflows, on-device use, multi-step planning. A credible local branch of the runtime tree.

Smart routing example — one workflow, many brains

Local model classifies issue

→

GPT-5.5 writes the patch

→

Review model checks diff

→

Claude for architecture judgment

User doesn't care which brain handled which step. User cares the work came back right.

↕

Layer 4 — The strategic layer

OB1 — Open Brain (user-owned memory)

Continuity layer

OB1 Agent Memory

Memory that lives outside any single brain. Not personalization — operational context. Project conventions, decisions made, prior failures, current tasks, constraints. Survives model churn, pricing changes, and session death.

Your live infrastructure

Supabase Edge Functions

PostgreSQL + pgvector

OpenRouter embeddings

agent-memory-api v0.1.0

Dashboard (local HTML)

7 memory tools

openbrain_recall

openbrain_writeback

openbrain_inspect

openbrain_review

openbrain_usage

openbrain_queue

openbrain_get_recall_trace

Memory types stored

decisions

lessons

constraints

failures

outputs

open questions

work logs

artifacts

Why memory is the strategic layer: If memory lives inside a chat transcript → workflow dies with the session. If it lives inside one provider's product → locked in. If it lives in markdown files → retrieval problem. If it lives in a user-owned layer with provenance, recall, and review → you have architecture.

↕

Layer 5 — What makes it safe

Provenance + permissions (trust layer)

Trust layer

Provenance + review

Without clear labels, memory gets dangerous. A more capable model with sloppy permissions makes the system more dangerous, not less. Provenance is what makes memory operational instead of sludge.

Memory provenance status

observed from a real source

inferred by a model

user_confirmed by you

imported from transcript

generated by agent

Review actions

Confirm → can use as instruction

Evidence only → reference, not instruction

Reject → removed from recall

Mark stale → deprioritized

Dispute → flagged for review

Safety rails (live in API)

Blocks private keys, API keys, credentials

Blocks raw transcripts and large code blocks

Content hash deduplication

What you can build

Durable workflow examples

A durable workflow has a job, a place to run, memory of what happened before, and enough structure that the model can change without destroying the workflow.

Repo operator

Watches GitHub issues + PRs. Triages incoming work. Compares against past fixes. Knows which files are risky. Remembers tests that catch regressions. Local model classifies, GPT-5.5 patches, Claude reviews architecture.

Email orchestration

Segregates sensitive emails. Drafts replies with tone matching. QA pass on threading. Handles attachments securely. Requires: memory of how you like it done, execution, durable memory so next pass works.

Incident response

Gathers context from logs, Slack, GitHub, runbooks. Identifies changes. Compares against prior incidents. Drafts updates. Suggests rollback candidates. Turns resolution into postmortem.

Meeting → execution

Takes meeting decisions, writes them to memory. Next agent session picks up where the meeting left off. Tasks, owners, and constraints survive the session.

Sales operations

Customer feedback loops, pipeline updates, competitive intelligence. Memory tracks what changed, what was promised, what was delivered.

Knowledge maintenance

Personal or team knowledge base. Lessons, constraints, decisions accumulate. Any agent can recall them. Provenance ensures trust.

The post-April thesis

The full stack, one line each

OpenClaw	Gives agents an action layer that actually works
Models	Provide a reasoning engine (swappable, contested)
TaskFlow	Gives work a durable loop with state and recovery
Channels	Where humans interact (Slack, browser, CLI, etc.)
OB1 Memory	The continuity layer — user-owned, brain-independent
Provenance	The trust layer — permissions, review, safety rails

The builder takeaway: The labs will keep fighting over OpenClaw's brain. That's inevitable. The builder response should not be religious loyalty to any provider. It should be architecture. Build the runtime so the model can change. Build the memory so the user owns it. Build the workflow so it survives the session. The scarce asset is not access to a model — it's ownership of the memory, the tools, the permissions, and the operating rhythm around the model.

Architecture diagram based on Nate Jones / Open Brain (OB1)

Source: youtu.be/85Q9htV2CBE · Built by Super-Intelligent AI

github.com/NateBJones-Projects/OB1