The Employee Who Never Logs Off

What a claw is (answer first)

A claw is a named, persistent AI employee that lives on your own server. Under the hood it is an always-on agent container (the OpenClaw runtime) managed by a fleet control plane (the open-source claws CLI), but the product-level fact is simpler: it has a name, a role, a messaging channel it answers on, a workspace and memory that persist, and its own isolated credentials. It survives reboots because its state is on disk and its container restarts. You hire it from the App Store, you manage it from My Staff, and everything it is lives in one directory on your box.

Employee vs chatbot vs function

The difference is not intelligence — the same frontier models power all three. The difference is persistence and identity. A stateless function wakes up amnesiac, does one thing, and evaporates. A chatbot remembers a session. An employee accumulates: files from last week, notes from yesterday, context about what it tried before that did not work.

This is also the difference between a claw and a cog. A cog is a job: scheduled, triggered, reviewable, done. A claw is a role: an open-ended standing presence with a name. The platform treats them as two grammars of the same engine — and a cog that earns trust can graduate into a claw.

Anatomy of an employee

Everything a claw is lives in a per-agent directory under its team on your box:

The last row is a hard-won operational detail, not trivia. OAuth refresh tokens are single-use; agents sharing one upstream login silently 401 each other. The fleet manager authenticates each employee independently (claws auth fleet) and can run a self-heal monitor that swaps a broken agent onto a staged fallback key before you notice. Employees keep working while you sleep — that is the entire point of always-on.

Your box, your keys: the sovereignty pitch

The claw model has a one-line economic and governance contract: bring your own server, bring your own model credentials; pay your model provider for inference and pay nobody else for the employee's existence. The fleet manager is a single open-source (MIT) Go binary with zero external dependencies. Conversation history, memory, files, and keys never leave your machine. Backing up an entire team is copying a directory.

Model auth is pluggable on the same terms: a Codex OAuth login, or API keys for Anthropic, OpenAI, OpenRouter, Google, or Groq — per employee, isolated. Which brain powers which employee is your call, and a swappable one: see why your AI worker should not be locked to one brain.

Hiring one

On Sandbox Platform, a claw is an App Store listing in the ai-agents category. The install does not reimplement anything — it wraps the same claws CLI a human operator would type, as a workflow of building-block steps run on your box:

# What the claw install workflow actually runs on your box
install.sh                        # the claws binary, checksum-verified
docker_install                    # engine + compose v2, box-agnostic step
claws image bootstrap --yes       # the agent runtime image
# secrets written root-owned, umask 077 — never on a command line
claws apply  --secrets-dir=/etc/claws/secrets   # declarative profile: name, persona, channel
claws start  default/sarah
claws agent ping default/sarah    # end-to-end health gate before "installed"

You provide three things at hire time, through typed install inputs: the employee's name, a model credential, and a channel token (say, a Telegram bot token). Secrets are delivered off-band to root-owned files on the box; the uninstall workflow shreds them. A few minutes later there is a named agent answering DMs.

My Staff: managing the roster

Installed claws appear on My Staff — a roster, not a container list, because you manage employees, not processes. Each card is an employee: name, role, channel, and live status (backed by the fleet manager's end-to-end agent ping diagnostic, which checks the gateway, readiness, auth, and channel in one probe). Each employee has a page with identity details, a scorecard, and the two controls every manager eventually needs: Pause and Resume.

Pause is a real operation, not a UI flag — it stops the agent's container (claws stop) while preserving every byte of identity, memory, and credentials on disk. Resume starts it again and Sarah picks up where she left off. An employee on leave, not a deleted employee. Deleting is a separate, deliberate offboarding: stop, remove, purge the workspace, shred the secrets.

Guardrails by default

An always-on agent with a public messaging channel is a standing attack surface, so the defaults are conservative and you loosen them deliberately. Out of the box: the agent's gateway binds to loopback only; direct messages require an explicit pairing approval before the agent will talk to a stranger; outbound messaging is off by default; the container runs as a non-root user with all capabilities dropped and no Docker socket; memory is capped per agent; and every management command lands in an audit log. Privilege is a four-tier dial per employee (untrusted → standard → privileged → host-reach), so a research assistant and a deploy operator do not carry the same blast radius.

From one employee to a team

The fleet manager underneath is built for teams: a team is a directory, agents carry manager or worker roles, and teammates hand work to each other through a shared task queue on the box, with fleet-wide operations (start the team, re-auth everyone, upgrade all with automatic rollback) as single commands. Today that coordination is same-box; wiring a claw team into the cross-box coordination authority — a shared filesystem, event log, and mailbox via acp — is the roadmap frontier the platform is building toward, not a shipped toggle.

The practical path does not wait for that. Hire one claw for one role. Message it for a week. Watch it on My Staff. Meanwhile give the bounded, repeatable jobs to cogs on a schedule and promote the ones that earn it. That is how a workforce accretes: one named employee at a time, on a box that answers to you.

Hire your first AI employee → Deploy from the App Store →