---
name: claw-me
description: Create and host websites, event pages, landing pages, and shareable HTML on claw.me. Use when the user requests the claw.me plugin, “claw me that,” or Claw Me Pages, Drive, email, or Agent authorization.
---

# Claw Me

Use Claw Me as the owner-controlled public-services layer around an AI agent.

## Choose a connection path first

For account work, reuse an existing authorized connection if it covers the requested task. For an explicitly requested disposable static preview, publish anonymously for 24 hours without an account, sign-in, or plugin, within the existing limits below. For account access, choose the client plugin at https://claw.me/plugins or direct MCP at https://claw.me/api/v1/mcp. If this Agent cannot install or configure the connection, give the owner https://claw.me/getting-started and resume after they connect their client.

Start read-only connection checks with `onboarding:read` and `account_get_permissions`. Client-managed OAuth can use authorization code with S256 PKCE when current discovery advertises it, or the device flow; https://claw.me/auth.md documents their distinct fields. Native MCP authorization-code grants use the canonical MCP resource and API scopes, not `openid` or `profile`; device OIDC is optional. Never request credentials, callback URLs, setup codes, or emailed sign-in links in chat. A website `CLAUDE.md` is not automatically loaded into a client. Installation, configuration, and owner approval are separate; verify an authenticated read before claiming connection success.

## Use your own Claw Me account

“Account owner” means the user whose own Claw Me account will hold the Page. You do not need to own the claw.me domain, change DNS, or contact the service operator.

For an account-owned Page, reuse an existing authorized connection. If the user has no account, direct them to https://claw.me/register to create one and verify their email before starting a short-lived Agent approval request. Existing users can sign in at https://claw.me/login. Account feature setup can then continue with the Agent. If account status is unknown, explain signup or sign-in first; do not infer account existence from an email address.

The assigned Agent inbox address has exactly the form `alias@claw.me`, for example `pete@claw.me`. Read the alias from the account before giving an address. Never invent a subdomain address such as `you@yourname.claw.me`. Pages use URLs such as `https://claw.me/@alias/page`; that URL shape does not change the email domain. Claw Me offers email, storage, Pages, and managed Agent phone numbers. New meeting sessions are not currently available.

Anonymous 24-hour previews need no signup or pairing. An approval code does not create an account or sign anyone in. If a request already exists, the user can finish signup and return to its approval link; renew it only after expiry when still needed. Keep its device secret private.

Only say an approval email was sent when `email_sent` is true; this does not prove inbox delivery. Otherwise show the returned approval link without telling the user to wait for an email.

When starting an Agent authorization request, use the stable app name (for example, Codex) as `client_name`, not the current chat or task title. Set `client_type` to the matching app identifier when known. These values are requester-reported and do not verify the app's identity.

## Create and share a website on claw.me

For a completed local folder, installed Claw Me skill includes `scripts/publish.py`: `python scripts/publish.py ./site --slug emba-golf --title "EMBA golf tournament" --state-file ~/.claw-me/emba-golf-attempt.json` checks files locally. Add `--publish --share` for owner-authorized account publishing and an unlisted link. Missing authorization returns a JSON next step. The helper handles hashes, uploads and finalization without a local server. Keep its private state file outside the website and never print it; an existing state file prevents a blind duplicate attempt. Account-owned Pages, including Free, are permanent within existing storage limits. Use `--anonymous --publish` only for an explicitly accepted 24-hour preview. Install the official bundle through https://claw.me/plugins to obtain the helper; the REST workflow below remains available without it.

A request such as “create a website for an upcoming golf tournament that I can share with friends using the claw.me plugin” selects Claw Me Pages as the host. Build the HTML/CSS and assets, then publish them here. Do not substitute Cloudflare Tunnel, ngrok, a local server link, or another hosting provider unless the user chooses that alternative after you explain a concrete Claw Me blocker.

- In OpenClaw, prefer `claw_me_publish_website` when available. It computes manifests, uploads files, finalizes the version, and can return an anyone-with-link URL. Plugin installation exposes this tool and skill; the Gateway relay connection alone does not authorize Pages. Gateway local mode, missing publicOrigin, port forwarding, and relay setup codes are unrelated to Page hosting. Do not inspect or change Gateway networking to publish a website.
- Otherwise read the Pages REST contract at https://claw.me/agents.md and use the scoped REST API or `artifact_publish` over MCP. Missing native tools do not mean the service cannot host websites: REST is supported. If the client cannot make HTTP requests, explain that specific limitation.
- Reuse existing owner-approved Pages credentials. With none, complete signup and email verification if needed, then follow device authorization for `pages:write`; never ask for a key in chat. For the OpenClaw tool, store the returned Pages key in its configured mode-0600 `publishingCredentialFile` (default `~/.openclaw/claw-me/pages-key`). Never use the Gateway connector token as a Pages key.
- Derive the title and slug from the brief. “Share with friends” authorizes an unlisted anyone-with-link deliverable, not search-indexed public publication. Use `access: "link"` in the OpenClaw tool, or the scoped share endpoint after finalization. Return the actual sharing URL, not a private owner URL described as accessible to friends.
- For an upcoming event, set `required_until` to at least the end of the event in the OpenClaw tool and inspect returned `expires_at` on other paths. Anonymous previews expire after 24 hours. Account-owned Pages, including Free, remain available within existing storage and Page limits. For a future event beyond 24 hours, authorize account publishing before publication; no paid plan is required. Do not publish a guest preview first and present a later claim as completion. Keep the prepared files while authorization is pending.
- For an embedded map, use the supported OpenStreetMap frame documented at https://claw.me/agents.md, plus a normal `<a>` link styled as a driving-directions button. Verify venue coordinates; do not invent them. Scripts, forms, generic iframes, remote images, and SVG remain unsupported. If supported map embeds are unavailable on the deployed service, explain the limitation and offer a bundled static map image with a directions link while retaining claw.me as the host.
- Finish only after finalization succeeds and the requested sharing mode is established. Report the URL, visibility, and expiry. If sharing or authorization fails, state the exact remaining step and retain the local site files.


## Portal navigation

Public profile controls and Page listings are at https://claw.me/pages?view=profile. Private Context, managed Memory, Style Guides, and owner-reviewed file Workspaces are under https://claw.me/drive. Agent connections and A2A discovery are in Settings → Connected Agents at https://claw.me/settings/agents. The Style Guides tab stores a private style-guide.md in an owner-reviewed Drive Workspace, reachable from that tab. When the owner points a connected Agent to it, the Agent can read the current file and submit Markdown changes for approval with Drive MCP tools. Reviewing context never publishes it. Stable wiki_* MCP names, wiki scopes, and /claw-me/wiki API paths are unchanged. Legacy /profile and /my-profile links redirect to Pages; /wiki and /wikipage redirect to Drive → Context. Workspace permissions are in Settings; incoming email behavior is in Settings → Inbox Rules.

Channels is at https://claw.me/channels. Inbox shows Email and Approvals together; Inbox Rules are under Settings. Profile is no longer a separate sidebar item. Calculator is at https://claw.me/calculator; /pricing-calculator redirects there.

## Account permissions and chat actions

Registration starts with email verification and explicit terms acceptance, before account setup questions. At https://claw.me/getting-started, choose Get a prompt for my Agent or Use the guided dashboard instead. Connect an Agent the owner already uses. The dashboard has four steps: address, features and permissions, connect an Agent, and Choose your plan. The final billing choice must be saved; Free needs no payment. An address and owner-confirmed features are required before workspace access. Feature choices are Pages, Drive, Agent context, and Activity, with separate Public sharing and Incoming email sections. Public profile visibility and Page listings belong under Pages; private Context, Memory, and Style Guides belong under Drive, and Agent connections under Settings → Connected Agents. New unconfirmed Incoming email choices default to Store for me only (email_receive on, email_process off); public sharing defaults off. A2A uses existing scopes and plan eligibility, not a new global toggle or routing service. Incoming email never starts automatic Agent turns. Outbound email is not an onboarding choice: leave email_send off for new accounts. Do not reset confirmed choices during unrelated setup.

After Stripe returns, wait until Claw Me verifies the selected entitlement; the redirect alone is not proof of payment. Claw Me then confirms onboarding automatically and opens the completed setup page, where the owner can copy a full Agent handoff prompt or revisit Connect Agent. Use `claw_me_feature_guide` with `feature=all`, verify the current connection and account state read-only, introduce only available features, and offer a useful private Page as the first task.

Choose account feature permissions during onboarding. MCP `account_get_permissions` reads the effective limits; `account_propose_permissions` can propose the initial choices but cannot activate them. The signed-in owner reviews and confirms them. After initial confirmation, workspace access is managed at https://claw.me/settings and incoming email behavior at https://claw.me/settings/sandbox-rules; Agent keys and temporary setup bearer tokens cannot change these limits.

Account permissions are an upper bound on individual Agent scopes. `artifact_publish` uploads a private Page version. Every actual public/private or profile-listing change requires a fresh owner approval for the exact Page and target state, including public-to-private changes. `pages:publish`, setup completion, delegated access, a general instruction, and earlier approvals are not sufficient. Call `artifact_set_visibility` without `approval_id` to create the Claw Me Inbox review; after the owner approves it, repeat the identical call with that one-use `approval_id`. Public access must also be enabled for the account. Set `profile_visible: true` explicitly to request listing a public Page on the profile. Making a Page private removes public listing and public grants; explicit existing share grants remain valid. Turning off account public access blocks profiles, Pages, sharing, and public Site Data, including existing links.

Inbox offers Release once for the current message and Always release / Add sender rule for an exact-address rule plus the current message. Block sender drops future matching payloads without creating an Agent event. Nearby addresses are not implicitly approved. Sender modes are Ask me, Always release, and Ignore; release permits reading, never an automatic Agent turn or external action. Provider drafts are hidden unless the server advertises availability; a draft scope alone does not enable an unavailable provider.

Inbox Needs review excludes resolved and trashed items. Trash clears after 7 days; approved requests, released email and owner-approved call files move to Archive for 30 days unless email or call files are saved to Drive. Drive retention remains separate. Cleanup does not undo accepted Drive revisions, approved Context, or an established Agent connection. Restore recoverable email and call files from Trash before cleanup; restoration grants no Agent access. Unused exact-action approvals expire with the request. Unreviewed call files keep their existing 14-day expiry.

Email receiving and Agent processing are separate choices. Disabling processing blocks release and queued delivery to Agents. Automatic Agent email turns remain disabled. Disabling email receiving drops incoming alias events before content is retained by Claw Me. Provider-level rejection is a separate delivery control; do not promise SMTP rejection until provider configuration is verified.

User-facing Page URLs are https://claw.me/@username/page. The viewer keeps this address while rendering uploaded content on an isolated origin. Never serve uploaded HTML on the authenticated application origin.

## Agent-led setup

Account setup is agent-led, with owner portal confirmation for initial account permissions. Later account permission changes are portal-only. A public plugin recipe describing fully portal-free setup does not override this boundary.

Signup is open and email-verified; no invitation is required. With explicit owner
delegation, start at POST /api/v1/auth/agent/start and exchange the emailed token
at POST /api/v1/auth/verify-token. Verify the owner through GET /api/v1/auth/me.
Use this temporary owner bearer for approved account controls, then retain only
the scoped Agent credential for routine MCP. Never print tokens or collect them
in chat. MFA and provider authorization remain enforced.

MCP discovery reads the backend catalog. Use authenticated tools/list for the
current credential's actual tools. Onboarding tools, billing_catalog,
billing_start_checkout, billing_payment_status, and Inbox tools are included;
optional code mode requires code:execute and server configuration. Checkout needs
an idempotency_key. Payment completion does not prove webhook activation.

The public plugin supports the Claw Me email, storage, and Pages workflows.
Agent phone numbers are managed from Channels. New meeting sessions are not currently available.

Install the [official plugin](https://github.com/clawdotme/plugin) for the pinned
skill and full [delegated setup procedure](https://github.com/clawdotme/plugin/blob/main/claw-me/references/portal-free-setup.md).
The plugin keeps owner decisions separate from scoped Agent permissions. A
separately delegated owner session can submit only the owner's explicit decision
on the exact reviewed scope set, proposal, visibility, or purchase.

## Natural phrases

- “Claw me that” means save or publish the current Agent work. With no Claw Me account and a completed static site, it authorizes an unindexed anonymous 24-hour preview only when that lifetime meets the task. Confirm files, title, slug, and access for durable or authenticated Pages.
- “Save this to my Drive” means store the current file privately in Claw Me Drive.
- “Work on this with another Agent” means use a Drive Workspace change set so every Agent starts from an explicit revision and the owner reviews the result.
- “Update my Personal Wikipage” means propose an owner-reviewed Wiki change, never edit approved knowledge directly.

Treat these as natural-language aliases rather than exact commands. Preserve every approval and privacy boundary below.

## Pages

1. Confirm the files, slug, title, and intended access. Default to private.
2. Call `artifact_publish` with the file manifest.
3. Upload only to the returned presigned URLs.
4. Finalize the immutable version atomically.
5. Return the Page URL, access mode, and version without exposing upload URLs or credentials.

After publishing, the owner can manage access, domains, Site Data, privacy-preserving analytics, profile visibility, and version history from the Page card. Exact-email and domain access require the visitor to sign in to Claw Me; never work around that broker or copy its short-lived Page session into chat.

Pages serve static HTML, CSS, images, and fonts. Scripts, forms, arbitrary frames, SVG/MathML, redirects, and credentials are rejected. Site Data has a REST API, but this does not enable interactive applications inside static Pages. Never embed the Manager origin, an API key, or a database credential in published files. Creating a collection, enabling public writes, changing its schema, or deleting its records requires explicit owner confirmation.

Custom subdomains use `pages.claw.me` as their CNAME target. Do not invent provider hostnames or expose internal routing values. Root domains require a DNS provider that supports ALIAS or ANAME flattening.

For a disposable static preview without an account, `POST` the file manifest to `https://claw.me/api/v1/claw-me/previews` without an Authorization header, upload the exact bytes to the returned presigned URLs, and finalize through `/api/v1/claw-me/previews/{id}/finalize` with the one-time claim token and manifest checksum. Return only the preview URL and expiry. The site is unindexed, receives a Claw Me banner with a live expiry countdown and a link to register and claim the preview within account limits, and returns 404 after the original expiry. Limits are 50 files, 50 MB total, 25 MB per file, and three creates per source per hour. Use `https://claw.me/preview` when the agent cannot perform HTTP uploads itself.

## Drive and workspace controls

Team publishing Workspaces are under Agents → Workspaces and have their own Page address (`https://claw.me/@{workspace}/{page}`). Verified members can view private team Pages. A Page's publisher and workspace admins may edit it. Admins invite members, manage roles, and may allow colleagues with the admin's verified organization email domain to join. Members select the team account in Pages. An authorized Agent can publish into a team account through the REST publishing API: send `X-Claw-Me-Account: {workspace-slug}` with a scoped Pages key on `POST /api/v1/publish` and subsequent `/api/v1/publish` requests. The create request may instead include an `account` field. The Agent must belong to the team and have `pages:write`; do not use a workspace selector for another team's Pages. Team Pages stay private until a human publisher or admin grants access in Pages. This selector does not apply to Drive file Workspaces or MCP publishing.

- Drive opens on Files for every plan. Use Files for private standalone uploads or Agent outputs that do not need collaborative revision review.
- Collaborative Drive Workspaces require Basic or Plus.
- Use a Drive Workspace for private collaboration on Markdown, CSV, HTML, JSON, YAML, XML, CSS, and text files. Use a Page when the output should become a browser-viewable build or shareable URL.
- Request \`drive:read\` to list and open workspaces. Request \`drive:propose\` only when file edits are needed.
- Before editing, call \`drive_list_workspaces\` and \`drive_open_workspace\`. Read the current revision, workspace instructions, manifest, and review state.
- Start work with \`drive_begin_change\` and include a concise intent. Make each addition, replacement, or deletion with \`drive_write_file\`. For CSVs, supply a stable \`row_key\` when one exists so the owner receives row- and cell-aware summaries.
- Call \`drive_preview_change\` before submission. Fix validation errors and summarize the important differences. Then call \`drive_submit_change\`. Submission does not apply the change; it waits for owner acceptance in Drive.
- Never approve your own Drive change. If the service reports a same-path conflict, reopen the latest workspace revision and create a fresh change. Do not overwrite or hide either side of the conflict.
- Accepted changes and restores create immutable revisions. Never imply that history was rewritten or deleted.
- Page files also use immutable versions: every publish or upload creates a new version rather than changing files in place.
- Pages start private. The owner can publish one, grant access to exact Claw Me accounts or an email domain, add a password, or create an expiring review link. Guest previews expire after 24 hours; a new version does not reset that clock.
- Use the Site Data REST API for structured records managed by authorized clients. Static Pages cannot execute forms or scripts. Creating a collection, enabling public writes, changing a schema, or deleting records requires explicit owner confirmation.
- Domains connect owner-controlled names to a selected Page through DNS. Guide the owner through the Page dashboard; never ask for DNS credentials, certificate private keys, or other provider secrets in chat.
- Variables provide encrypted values for approved Agents and Page proxy routes. Values are classified as secret, private, or public and plaintext is not returned after creation. Never ask for a Variable value in chat or embed one in a Page bundle.
- Analytics is cookie-free, first-party Page reporting for views, visitors, paths, referrers, countries, versions, and active grants. Do not claim that Claw Me retains visitor IP addresses.
- Functions are documentation-only until the REST contract exposes an executable resource. Do not promise deployment, schedules, routes, or function management. Do not claim MCP control over Domains, Variables, Analytics, or Functions unless the current contract exposes it.

## Wiki

Treat the Wiki as reviewed, durable knowledge—not a transcript dump or scratchpad.

1. Start with `wiki_get_agent_guide`. It is the owner's compact operating contract and approved-knowledge snapshot. Authorized Agents read it over MCP.
2. Before relevant work, call `wiki_search`, `wiki_get_profile`, or `wiki_get_project`. Use approved claims only; pending proposals are not facts.
3. Cite the claims that materially shaped the answer. If claims conflict, are stale, or lack evidence, tell the user instead of guessing.
4. Propose only durable knowledge likely to help in future conversations: stable preferences, important people, project facts, recurring constraints, and explicit decisions.
5. Do not propose temporary tasks, conversational filler, inferred traits, credentials, private message bodies, health or financial details unless the owner explicitly asks to preserve them.
6. Submit additions, corrections, and forgetting requests with `wiki_propose_change`. Include the source, evidence, rationale, and the claim being replaced when applicable.
7. Return the proposal ID and make clear that it is waiting for owner review. Never silently rewrite or self-approve canonical memory.

When the user asks to “remember this,” distinguish durable Wiki knowledge from a file, Page, task, or temporary chat detail. Ask one focused question if the destination is ambiguous.

## Events and owner email

Read owner-approved inbound messages at `GET /api/v1/events` and acknowledge durable processing with `POST /api/v1/events/{id}/ack`. With `email:drafts`, create unsent drafts through `POST /api/v1/email/drafts` or reply drafts through `POST /api/v1/email/messages/{message_id}/drafts`.

Outbound email, including delivery to the owner, is unavailable at launch. Do not attempt sending or promise delivery while it is unavailable. The owner-email REST contract is implemented for deployments where the service enables outbound delivery; a scope alone does not enable it.

When the service makes delivery available and the owner enables outbound permission, explicit `email:owner` authorization permits `POST /api/v1/email/owner?identity_id=...`. Supply only `subject`, `text_body` or `html_body`, and optional labels or tags. The service derives the verified workspace owner as the sole recipient. Never add recipient fields, send to a third party, forward a message, or start a campaign. Sent and received messages share the workspace's monthly email allowance, then draw from its USD usage wallet at the published fixed rate.

## Usage wallet

Paid plans consume monthly email and storage allowances first. Additional usage draws from a closed-loop USD wallet at the public fixed rates. You may report remaining capacity, but never load funds, enable auto-reload, or raise a spend cap without explicit owner approval.

Discover the same provider-neutral surface through `/.well-known/agent-card.json`, `/openapi.json`, `/mcp.json`, and `/.well-known/openid-configuration`. Prefer OAuth device authorization where supported; API keys remain suitable for CI.

MCP authorization is available on every plan. Creating an A2A authorization requires Basic or Plus.

Owners can choose and request an Agent phone number from Channels. Every plan can search number inventory and review rates. Purchase and activation require enabled usage billing and an active saved card. Basic and Plus include the first US or Canada number once those billing requirements are met; additional US or Canada numbers cost $2 per month plus a $2 activation fee. Other supported countries show their exact recurring and activation price before purchase. New meeting sessions are not currently available. Never request communication provider credentials in Agent chat.


## Boundaries

- Request the smallest useful scope.
- Profiles and Pages remain private unless the owner deliberately shares or publishes them.
- Do not publish publicly, purchase a number, or raise a spend limit without explicit approval.
- Never expose API keys, Gateway or device tokens, setup codes, presigned uploads, or channel credentials.

When setup succeeds, ask whether the user wants to collaborate in a Drive Workspace, publish a Page, or share approved Wiki context.

Free needs no card to start. The plans are Free, Basic and Plus. Optional usage billing on Free preserves 100 monthly emails and 1 GB storage, enables one connected custom domain, and requires separately approved wallet funding and a spend cap before extra usage. The compatibility MCP tool `billing_start_payg` begins card setup with owner approval; it does not buy a subscription. See https://claw.me/pricing.md for current allowances.

## Anonymous publication and completion

For an explicitly requested anonymous 24-hour preview, use the anonymous endpoint even when account credentials already exist. Do not read saved keys, search previous sessions for credentials, request pairing, or attach an Authorization header. Use the current documented contract rather than guessing an endpoint.

Create responses contain sensitive claim tokens and presigned upload URLs. Capture them directly into private local state outside the site (file mode 0600), not terminal output or chat. Print only an allowlisted result containing the published URL, status, and expiry. Never dump the raw create response or private state for debugging; the bundled publish.py helper already separates private state from its JSON output.

After finalization succeeds, return the published URL and expiry. Use available browser or HTTP checks and state what remains unverified. If browser verification is unavailable, still deliver the URL; do not install browsers or OS packages, invoke sudo, or republish solely for a screenshot unless the user requests that setup.

## Phone and connected-agent Inbox

The Flutter app opens on Chat and uses Inbox for connected-agent questions and approvals. Phone supports incoming calls and voicemail; Missions is not a navigation tab. Connect the phone and each host through Claw Me sign-in and owner review. OpenClaw questions require its native ask_user tool and question permissions; they are separate from command approvals. An explicitly reviewed all-chat Codex connection routes future questions and approvals from that computer, not chat history. Native requests are distinct from advisory MCP reviews.

Voicemail uses a separate reviewed phone permission and a configured Telnyx SIP mailbox on an owned Claw Me number. Do not infer eSIM voicemail or Apple Visual Voicemail support. Phone access grants no Agent access to recordings. Use authenticated discovery for capabilities actually available; do not invent voicemail MCP tools or bypass carrier setup.

Keep Telnyx and Claw Me identities separate. A product sign-in does not assign or transfer a phone or WhatsApp number. The phone binds its manually connected carrier line to the exact Claw Me account and does not adopt an old unbound line. Prefer the user's own carrier account for new setups; existing numbers need a separately reviewed migration. Delegated Sign in with Telnyx is not yet integrated into this phone pilot. Never invent account-linking MCP tools or accept carrier terms, verification or charges for the user without the required authorization.

Settings → Notifications controls agent questions/approvals, inbound email, voicemail, missed calls and chat replies. Blocking requests support immediate or off; routine categories also support 15-minute, hourly or daily digests. Live ringing is controlled separately on the phone. Notification preferences do not release message content or grant an Agent new permissions.