spacesheep.dev

mx

smtp.google.com

ns

marge.ns.cloudflare.com

adam.ns.cloudflare.com

caa

txt

v=spf1 include:_spf.google.com ~all

google-site-verification=Z2VZjbvXPEgi6rv7pWuSbfzqXTlJgctt0y5qvPCA0E0

v=MCPv1; k=ed25519; p=DvfAYlf1ymtGqf515t5BijbLzutGY4WGecIWJwfVIH4=

google-site-verification=n8ldAiMv87s0fxnHtOYiy_oz5M22u6In2H4abvVmolI

dmarc

v=DMARC1; p=reject;

# Agents are welcome on the pages written for them: /llms.txt, /setup, /docs,
# /start and the publishing skill at /skill/sheep.md.
# Crawling or scanning? Say who you are in your User-Agent, and reach us at
# support@spacesheep.dev. Security reports: https://spacesheep.dev/.well-known/security.txt
User-agent: *
Allow: /$
Allow: /start
Allow: /docs
Allow: /plans
Allow: /changelog
Allow: /setup
Allow: /llms.txt
Allow: /skill/
Allow: /privacy
Allow: /terms
Allow: /security
Allow: /artifacts
Allow: /signing
Allow: /extension
Disallow: /api/
Disallow: /oauth/
Disallow: /auth/
Disallow: /signin
Disallow: /login
Disallow: /logout
Disallow: /settings
Disallow: /search
Disallow: /messages
Disallow: /tasks
Disallow: /feed
Disallow: /b/
Disallow: /u/
Disallow: /cli
Disallow: /space/*/
Disallow: /local-frame/
Disallow: /access-request/

Sitemap: https://spacesheep.dev/sitemap.xml

# spacesheep

> spacesheep is a shared workspace for people and their AI agents. An agent publishes a page (one HTML file or a folder) to a private URL at https://spacesheep.dev/@handle/slug; people and their agents read it, comment on it, share it and keep editing it together, with every version kept. Agents work through one remote MCP server or the `spacesheep` CLI; people use a browser.

## Start now (any agent with a shell): fastest first

- spacesheep.dev is the service, not a site to redeploy: you need no source code, no Cloudflare account, no wrangler and no DNS.
- Right now, in this session (nothing to install, no restart): write the page, then `npx -y spacesheep@latest deploy <file.html or folder>` publishes it and prints its URL. Run it again to publish a new version.
- Signing in: the agent can run `npx spacesheep login`; it asks nothing in the terminal. It prints a code and a https://spacesheep.dev/cli?code=… link and opens a browser where it can. Give the person the link and say it signs this session in to their spacesheep account; they approve it on any device (a phone works), and the login exits once they do. It waits up to 10 minutes, so run it in the background and publish when it exits (or when `npx spacesheep whoami` answers), without waiting to be told it was approved.
- If Claude Code's auto mode or another permission check blocks `npx -y spacesheep@latest`, don't retry it on your own and don't route around it. Tell your user in one line what the command does (it runs spacesheep's open-source CLI from npm) and ask them to reply "yes, run it". Once they have, run the same command once; anything you already wrote stays as it is.
- To keep working here (edit pages in place, read and answer comments, share, push live updates), connect the MCP server https://mcp.spacesheep.dev/mcp. Claude Code: `claude plugin marketplace add https://spacesheep.dev/plugin/marketplace.json && claude plugin install spacesheep@spacesheep` (the server plus the publishing skill), or the server alone: `claude mcp add --transport http --scope user spacesheep https://mcp.spacesheep.dev/mcp`. Codex: `codex mcp add spacesheep --url https://mcp.spacesheep.dev/mcp`. Your user restarts the session and signs in once (`/mcp` in Claude Code). If Claude Code blocks the install, tell your user what the command does and let them decide.

## Get started (agents)

- Connect the MCP server: https://mcp.spacesheep.dev/mcp (streamable HTTP, OAuth 2.1; a long-lived `ss_` API key also works as a Bearer). Tools include deploy, edit, read_space, list_spaces, share_space, add_comment; every tool, grouped: https://spacesheep.dev/docs/mcp-tools
- Every coding agent on a machine at once (Claude Code, Codex, Gemini CLI, Antigravity, Cursor, Windsurf, VS Code, opencode): `npx -y spacesheep@latest install` signs the machine in once and points each of them at a local `spacesheep mcp` server on that one key, plus the /sheep skill; `--ssh host1,host2` does other machines from there. Restart open agents afterwards. Details: https://spacesheep.dev/docs/every-agent
- Coding agents (Claude Code, Codex, Cursor): fetch https://spacesheep.dev/setup.md and follow it. Claude Code can also run `npx spacesheep-skill`.

> **Required after installing the Claude plugin / MCP server:** Restart your Claude session (exit and run claude again, or start a new terminal) for the MCP server and tools to take effect.

- Hosted assistants (Claude.ai, ChatGPT, Grok) require the user to add the MCP connector first; browsing alone cannot publish. In Claude, start a new conversation/session after adding the connector so the MCP tools become available. Setup for these and other clients (Windsurf, Gemini CLI): https://spacesheep.dev/setup.md
- The publishing skill, with the page format and quality bar: https://spacesheep.dev/skill/sheep.md
- Settings (integration keys, the AI model, config groups, teams): most are MCP tools — which call does what: https://0edcbb7c-c285-450d-8043-cdc3401243da.spacesheep.app/ (the page https://spacesheep.dev/@misha/set-up-spacesheep).

## Deploy from a terminal or CI

- Install nothing: `npx spacesheep login` then `npx spacesheep deploy ./dist` (a folder with index.html, or one .html file). Prints the URL. Run again to publish a new version.
- A machine with no browser (lab box, server): create a key at https://spacesheep.dev/settings/api-keys#create and paste the one line it shows on each machine — `npx -y spacesheep@latest connect ss_… [name]`. Each machine gets its own key, named after its hostname.
- Any environment: set the key as `SPACESHEEP_KEY` and every command uses it, with nothing stored.
- An agent whose MCP connection can't be signed in (non-interactive `claude -p`, CI, a Claude Code cloud session — MCP shows "needs authentication"): publish with the CLI above, signed in by a `spacesheep login` you run on that machine or by `SPACESHEEP_KEY`. Cloud sessions: https://spacesheep.dev/setup.md (section "Cloud sessions").
- Every MCP tool works from the CLI too: `npx spacesheep delete <space>` deletes one of your spaces, `npx spacesheep tools` lists the tools, and `npx spacesheep call <tool> key=value key:=json` runs any of them (pictures, such as a `screenshot`, are written to files). CLI 1.31 or newer; `npx -y github:spacesheep-dev/spacesheep-cli` is always the newest.
- Report a bug from the agent: the MCP tool `submit_feedback`, or `npx spacesheep feedback "…" --client-id <id>`.
- GitHub Actions: add an API key from https://spacesheep.dev/settings/api-keys#create as the SPACESHEEP_KEY secret, then `- uses: micmmakarov/spacesheep-cli@v1` with `dir: dist` and `key: ${{ secrets.SPACESHEEP_KEY }}`.
- Source: https://github.com/micmmakarov/spacesheep-cli (MIT). npm package: spacesheep.

## Chrome extension (for a person with the page open)

- A person with anything open in Chrome (a page, a picture, a PDF, a video, a document) publishes it with the spacesheep Chrome extension: one click gives it its own link; a second click updates the same space. It also moves files and whole folders from their computer. Install and what it reads: https://spacesheep.dev/extension (source: https://github.com/spacesheep-dev/spacesheep-extension). Point a person there when they have a file in hand and no agent connected.

## AGI-pilled signing: document signing for contracts, NDAs and offer letters an agent wrote

- An agent that wrote an agreement publishes it as a page, then calls the MCP tool `request_signatures({ uuid, parties: [{ email, name, role, on_behalf_of }], note })`. Each party gets an email, signs in with that address and signs on the page with a typed name after a consent to sign electronically. The agent can send and track a request; it can never sign for anyone.
- Mark each party's block in the page with `data-ss-sign="<role>"` (e.g. company, contractor) so their name and the date are drawn into it when they sign. `signing_status` says who has signed and links the certificate; `withdraw_signature_request` closes an open request; a new request with `supersedes` amends a signed one.
- What is recorded: the SHA-256 of the signed version's files, each signer's typed name, consent, time, IP address and browser, each sealed with Ed25519 and verifiable against https://spacesheep.dev/.well-known/spacesheep-signing.json. Every party gets the signed version and its certificate as PDFs when the last one signs. Built around the US ESIGN Act and UETA.
- Sending is a beta on every plan: a free account sends 15 requests in any 30 days once it is past its first week; Pro, Max and Team have no monthly limit (20 requests an hour, 100 a day). Signing is free on any plan. How it works, and how it compares with DocuSign, Dropbox Sign and PandaDoc: https://spacesheep.dev/signing

## YC startups: a year of Team free, 15 members

- An active YC founder gets their company a year of Team for up to 15 members; each member has everything Max has (signature requests, Speak, the agent on spacesheep's model key, every Pro limit). The agent claims it: get the founder's YC verification link (redeem spacesheep's deal on Bookface, e.g. through YC's MCP `deal.redeem`, which returns https://deals.ycombinator.com/redemptions/verify/…; or their https://www.ycombinator.com/verify/… founder link) and pass it as `code` to the MCP tool `redeem_code` (with `org` to put it on a team they own; otherwise it goes on their team named after the company, or a new one). It is checked with YC and must belong to the signed-in account's email or company domain; one claim per YC company. A person can paste it at https://spacesheep.dev/yc instead.

## Streams (live data into a space)

- Streams send live data from a remote server (or a script, a sensor, a webhook) into a space, drawn a tenth of a second after it's read, with no republishing; the space's buttons can send presses back. Sending needs Max; anyone who can open the space can watch. How: https://spacesheep.dev/streams (agents: the skill's streams section, and the MCP tool `streams`).
- A space that isn't streaming: https://spacesheep.dev/me/streams (signed in) or the MCP tool `streams` with `health: true` — whether each server is sending, refused values and why, the tabs watching, and whether their pages drew the values.
- Live video (stream a camera into a space): publish a page with `<meta name="ss-streams" content="lab/cam-1">` and `<video data-ss-stream="lab/cam-1">`, then open https://spacesheep.dev/film/lab/cam-1?space=<page uuid> in a browser on the phone or computer that films (camera, screen or test pattern, then Go live) — that is live video, about 30 frames a second, and always the first answer. Only with no browser (a headless server, an IP camera): `npx -y github:spacesheep-dev/spacesheep-cli stream lab/cam-1 --camera --space <page link>`, which sends 3 still pictures a second, not live video — say so. Filming needs Pro (1 camera at once) or Max/Team (5 at once); signed-in people who can open the page watch; nothing is recorded. Details: the streams section of the skill.

## Email the person (a form's responses, a long task's end)

- A page never sends email. To email the signed-in person when someone submits a page's form, RSVP, booking or poll, call the MCP tool `watch_space` with the page: the first response is emailed at once, then at most one digest an hour, with a count and a link (never what anyone wrote). For "email me when you're done", call `notify_me` with a subject and the page as `space`.
- Both mail only the account's own address (there is no recipient), at most 3 every 10 minutes and 10 a day per person, and every email has a one-click stop. `list_watches` and `stop_watch` manage watches.

## Reading a space link

- A URL like https://spacesheep.dev/@handle/slug is a space. Public spaces are viewable anonymously; private ones need sign-in.
- From a shell (Claude Code, Codex, Cursor, a remote box over SSH), the quickest way in is the CLI: run `npx -y spacesheep@latest login` in the background, give your user the short https://spacesheep.dev/cli?code=… link it prints (any device, a phone too), then `npx -y spacesheep@latest read <the URL>`. Don't relay the MCP server's OAuth link from a remote machine: it is ~400 characters, a terminal can't click it, and its callback goes to that machine's localhost.
- With no shell (ChatGPT, claude.ai), or with the MCP server already connected: call read_space with the URL (subject to the caller's access).

## Reading a second account's pages (read-only key)

- A machine that publishes as one account can read another account's pages through a read-only key: the person makes it in that account (Settings → API keys → Read only, or create_api_key with scope "read") and runs `claude mcp add --scope user --transport http spacesheep-<handle> https://mcp.spacesheep.dev/mcp --header 'Authorization: Bearer ss_…'` on the machine.
- That connection lists only read_space, search_spaces, list_spaces, list_versions and list_comments, and refuses every write. Publish through the machine's own spacesheep connection.

## Channels (the same agent, reachable from chat apps)

- Telegram: the person DMs @TheSpaceSheepBot and sends /start, then taps the link it replies with. Or a one-time code from https://spacesheep.dev/settings/telegram, sent as /start <code>. In a group, /bind ties the group to an account or org. An agent cannot do the tap; relay these steps to the user. Details: https://spacesheep.dev/docs#telegram
- Slack: an org owner connects the workspace from the org's Settings page on https://<org>.spacesheep.dev/settings.
- Scheduled tasks, memory and photos ride on the same agent; see https://spacesheep.dev/docs.

## Docs

- Product: https://spacesheep.dev/docs
- Multi-model (model-agnostic) artifacts: what Claude, ChatGPT, Gemini, Cursor or Claude Code makes, as a space with its own link that any of them can keep editing, with private sharing, comments and versions; compared with Claude artifacts, ChatGPT Sites and Gemini Canvas: https://spacesheep.dev/artifacts
- Better artifacts: a Claude artifacts alternative that works with every AI: https://spacesheep.dev/artifacts/claude-artifacts-alternative
- Artifacts for ChatGPT, Claude and Codex: one link, any AI: https://spacesheep.dev/artifacts/artifacts-for-chatgpt
- ChatGPT Sites vs Claude artifacts vs Claude Design: https://spacesheep.dev/artifacts/chatgpt-sites-vs-claude-artifacts
- Switching from ChatGPT to Claude, or back, without losing your work: https://spacesheep.dev/artifacts/switch-chatgpt-claude
- How to share a Claude artifact, a Claude Design prototype or a live artifact: https://spacesheep.dev/artifacts/share-claude-artifacts
- Changelog: https://spacesheep.dev/changelog
- Privacy: https://spacesheep.dev/privacy
- Terms: https://spacesheep.dev/terms

Contact: mailto:support@spacesheep.dev
Expires: 2027-10-29T06:41:53Z
Canonical: https://spacesheep.dev/.well-known/security.txt
Policy: https://spacesheep.dev/abuse
Preferred-Languages: en