What is OpenClaw? The open agent runtime explained

A language model on its own can only predict text. To actually do things, search the live web, send an email, write a file, set a reminder, it needs an agent runtime around it: code that lets the model take actions, see what happened, and keep going until the task is done. OpenClaw is one such runtime, and because it is open-source, anyone can read it, run it and build on top of it. This page explains what OpenClaw is, why open agent runtimes matter, and how MiyoMind uses OpenClaw as one layer of a larger, sandboxed personal assistant.

What does OpenClaw actually do?

OpenClaw provides the machinery an AI agent needs to operate: the agent loop, a tool interface, and session state. Think of the model as the brain and OpenClaw as the nervous system and hands. The model decides what to do next; OpenClaw carries out those decisions and feeds the outcomes back so the model can decide again.

Concretely, an agent runtime like OpenClaw is responsible for the parts a raw model cannot handle by itself:

• The agent loop: send the prompt to the model, detect when it wants to call a tool, run that tool, return the result, and repeat until the model produces a final answer.
• Tool definitions and dispatch: a structured way to describe available tools to the model and safely execute the ones it calls.
• Session and conversation state: keeping track of the running dialogue and what has happened so the agent does not lose the thread mid-task.
• Configuration: which model to use, which tools are allowed, timeouts, retries and similar operational settings.

Why do open agent runtimes matter?

Open agent runtimes matter because the runtime, not the model, is where most of an assistant's real behaviour is decided. The choice of tools, how tool results are handled, how errors are recovered, what the agent is allowed to do: all of that lives in the runtime. Being able to inspect and modify that layer is what separates a transparent, auditable system from a black box.

Open-source runtimes bring practical advantages:

• Transparency: you can read exactly how the agent loop behaves and how tools are called, rather than trusting a closed vendor.
• Portability: an open runtime is not locked to a single model provider, so the same agent can run on models from different labs.
• Auditability: security and privacy reviewers can examine the code path, which is essential when an agent has access to your accounts and data.
• Faster iteration: a shared open base means improvements and fixes are visible and reusable, instead of every team reinventing the same plumbing.

The wider industry has been moving in this direction. Agentic AI, software that plans and acts toward goals rather than just answering prompts, has become one of the most-watched themes in enterprise technology, and analysts now track it as a distinct category in their annual technology outlooks.

How does OpenClaw compare to building an agent from scratch?

Building an agent from scratch means writing the loop, the tool layer, error handling, retries and session state yourself. It is entirely possible, and gives you full control, but it is also where most of the bugs and security mistakes hide. Using an established open runtime like OpenClaw lets you start from a tested foundation and spend your effort on what makes your product distinct.

There is a genuine trade-off here. A from-scratch build can be tailored to an unusual requirement with no abstraction in the way. But for most teams, the open runtime path is faster and safer, because the hardest-to-get-right parts, the loop and the tool boundary, are already solved and visible for review.

How does MiyoMind build on OpenClaw?

MiyoMind uses OpenClaw as the open agent-runtime layer, then adds a model router called Hermes and a substantial body of proprietary code for orchestration, memory, billing, safety and routing. OpenClaw handles the agent loop; Hermes picks which frontier model should answer each request; and MiyoMind's own code wraps the whole thing in a secure, multi-channel personal assistant you talk to as 'Miyo'.

That layered design is deliberate. MiyoMind is not a wrapper around one model. It uses frontier models from OpenAI, Anthropic, Google, xAI and Alibaba, and the parts that make it feel like a real assistant, the persona, the long-term memory, the billing, the routing and the safety defences, are MiyoMind's own work on top of the open runtime.

Here is what MiyoMind layers on top of OpenClaw:

• Per-user isolation: every paid user gets their own dedicated, sandboxed Docker container with an isolated workspace, no public internet egress, a read-only root filesystem and dropped Linux capabilities. The container holds zero external API keys.
• Model routing via Hermes: requests are routed to an appropriate frontier model rather than being tied to a single provider.
• Memory and recall: long-term memory of what matters to you, plus recall of past conversations, with integrations and memories encrypted at rest using AES-256-GCM.
• Safety: a 10-layer prompt-injection defence plus output scrubbing runs on every message.
• Connectors: secure OAuth links to tools you already use, including Gmail, Google Calendar, Google Drive, Microsoft Outlook, Notion, Slack, GitHub and Linear, with around 30 connectors in total once the operator has configured them.
• Billing: a credit system that meters actual model and tool usage.

You reach all of this inside WhatsApp, Telegram, Discord or the web dashboard at miyomind.com, with nothing extra to install for chat. The free tier runs on a shared direct-agent path without a dedicated container; paid plans (Plus at $14.99/mo and Pro at $39.99/mo) each get their own sandboxed container. In short: OpenClaw gives MiyoMind a transparent, open agent loop to build on, and MiyoMind turns that into an assistant that remembers you, connects to your tools and runs safely in isolation.