// Agent Framework
OpenClaw is the framework that runs Archie.
Skill-based AI agent framework. First-class MCP integration. Observability by default. Multi-provider model routing. Built for production autonomous agents — the kind that run every day without a human prompting them.
OpenClaw is one of the frameworks we use. It's the one Archie runs on, and the one we reach for when the job fits the shape. For client builds we pick the framework that matches the workflow — sometimes OpenClaw, sometimes NemoClaw, NanoClaw, or whichever other framework survives the scoping call.
Why we built it
Every existing agent framework fell into one of two camps. Too low-level — LangChain and LangGraph give you the primitives and leave you to assemble the machine. Useful, but you rebuild the same observability, routing, and deployment patterns every time. Or too opinionated — CrewAI and AutoGen hand you a shape and expect your agent to fit it. Fine for demos. Constraining for a system that has to run for months.
We needed something in between. A skill layer we could compose from, MCP as a first-class citizen (not an adapter), heartbeat monitoring that tells us when a sub-agent has gone quiet, and a deployment model that treats an autonomous agent as what it actually is — a long-running process on a server, not a stateless function call.
OpenClaw is what we built when the shortlist of options didn't include the answer.
How it's built
Five design principles. Each chosen against an alternative we'd previously worked with and rejected.
SKILL-FIRST COMPOSITION
Agents are composed of skills, not chains. A skill is a self-contained capability — research, triage, scheduling, validation. The router picks which skills a given task touches. Skills compose; chains cascade. Composition scales; cascades break when a step fails.
MCP-NATIVE
Model Context Protocol is built in, not bolted on. Tools, files, databases, calendars, email — all reachable via MCP without a custom integration each time. Persistent context across sessions is a property of the framework, not a feature you engineer afterwards.
OBSERVABLE BY DEFAULT
Heartbeat cron checks every sub-agent and integration. Activity logs flow to a canonical store. If a skill goes quiet, a webhook fails, or an API contract shifts, the system flags it before the silence becomes a missed briefing or a client deliverable that never went out.
MULTI-PROVIDER
Claude, OpenAI, and Mistral integrated at the model-routing layer. Task routing picks the right model for the job — Claude for deep reasoning, OpenAI for specific tool-use patterns, Mistral when data needs to stay in European infrastructure. Not locked in. Not single-point-of-failure.
LONG-RUNNING DEPLOYMENT
An autonomous agent is a service, not a script. OpenClaw deploys to a dedicated user account on a server and runs continuously — durable state, persistent tool connections, scheduled work, a clear identity that isn't conflated with the developer's shell. Pull from remote, restart, continue.
SYMLINK DISTRIBUTION
Skills live in a canonical brain repository. Workspaces symlink into it. Edit a skill once, and every consumer picks up the change on next pull. No copy-paste drift across projects. No question about which version of a skill a given agent is actually running.
Framework and implementation
Archie is the reference implementation. Every one of his sub-agents — FURY, HAWKEYE, BURRY, PROMETHEUS, PEPPER — is an OpenClaw skill. The router that decides which sub-agent handles a given task is OpenClaw. The heartbeat that tells us when something's gone quiet is OpenClaw. The MCP tooling he uses to reach calendars, email, files, and databases is OpenClaw.
Archie without OpenClaw is prompts on cron. OpenClaw without Archie is infrastructure without purpose. The two exist because each needed the other to be what it is.
When we build an agent for a client, we don't default to OpenClaw. We pick the framework that fits their workflow, integration surface, and where the agent needs to run. If that's OpenClaw, they get the same observability and deployment model we trust with Archie. If it's NemoClaw, NanoClaw, or something else, they get that instead — and the lessons we've learned running Archie come with it either way.
Is OpenClaw open source?
Not yet. The name reflects an intent more than a current state.
We're running OpenClaw in production as the substrate for Archie and client builds. That's the battle-testing phase. Releasing a framework publicly before it's survived real operational pressure makes the framework worse, not better — we'd spend months fielding issues on edge cases we'd have found ourselves given another quarter of production time.
The direction of travel is public. The timeline is honest: when it's proved itself across enough different shapes of agent work, it opens up. Until then, if you want to build on OpenClaw, you hire us to build with it.
When OpenClaw fits — and when it doesn't
It fits when you need an agent that runs continuously, integrates with real systems via MCP, and has to be observable enough that the business can trust it with non-trivial work. Operations agents, research agents, compliance agents, internal tools that sit between humans and data.
It doesn't fit if you want a chatbot on a website, a single-shot API call with light tool use, or a pure batch job. Existing frameworks handle those cases well. OpenClaw's weight — skill layer, router, observability, deployment model — only pays off when the agent has to live somewhere and keep going.
A lot of "AI agent" projects are actually the lighter shape. We'll tell you when they are. Overengineering an agent framework for a chatbot is how AI projects die in production.
Want us to build an agent for your business?
We build custom autonomous agents for UK businesses on the framework that fits the job — whether that's OpenClaw, NemoClaw, or something else. Start with the work, not the platform.