The savant with no hands

A few months ago I asked Claude Code to close out my week.

It shipped the code. Wrote the release notes. Summarized the PRs. Then I asked it to send the summary to the team, drop the top-line metrics into our tracking sheet, and schedule a 15-minute retro for Monday.

It couldn't do any of that.

Not "it did it badly." It literally did not have the hands. The best coding model ever shipped, and it was stuck writing a three-line email into a chat window for me to copy-paste into Gmail.

That week I figured out what I had been watching for months. Claude Code is a savant with no hands.

The work is not the code

If you watch a small team for a week, the code is maybe 30% of what ships. The rest is the connective tissue. The release note. The sheet. The slide. The email. The task. The calendar hold. The Slack thread. The doc that says why.

Agents are phenomenal at drafting all of those. The models can write a crisper release note than I can at 11pm. They can rewrite a forecast from a napkin sketch. They can draft the follow-up to a customer and cite the exact line in the contract.

The bottleneck has never been draft quality. The bottleneck is that the agent can't do anything with the draft. It lives in a chat window. You copy it out. You paste it into the right tool. You fix the formatting. You hit send.

Multiply that by every artifact a team produces in a day and you get a pretty expensive AI subscription that still requires a human to be the mail carrier.

An OS is just a set of hands

Every operating system is a contract between a brain and a set of hands. The brain decides what to do. The OS exposes primitives (open a file, send a packet, write to disk) that turn the decision into something that actually happened.

Agents don't have that. Every agent ships with a chat window and a model. That's it. If the model decides it wants to create a note, there is no create_note() that reaches into the real world and creates one.

So we built it. Then the one for sheets. Then slides, mail, tasks, calendar, files, chat. Nine primitives that cover roughly everything a small team produces in a week.

Put together, they're an OS for an agent.

Two halves, one product

Spatio is two things, and both matter.

SpatioMCP is the hands. An MCP server that exposes nine primitives (notes, sheets, slides, mail, tasks, calendar, files, chat, contacts) as tools any agent can call. You drop four lines of config into Claude Code, Cursor, Codex, or any MCP-compatible client, and your agent can spatio_notes.create, spatio_sheets.update_row, spatio_mail.send. The agent you already love grows hands.

Spatio Desktop is the workbench. Every artifact your agent produces (drafts, rows, decks, replies) lands in Desktop, where you and your team review, edit, approve, and send. It is not another chat UI. It is a collaborative review surface.

You need both. The hands without the workbench means your agent is creating artifacts that scatter across six apps and nobody sees them until something breaks. The workbench without the hands is a nice review tool with nothing to review.

The way I think about it: your agent drafts at inhuman speed. Desktop is where your team catches up. One is the pace of the model. The other is the pace of the humans on the hook for what gets shipped.

I'll write more about Desktop soon. It turns out review, not prompting, is the real bottleneck at team scale. Different post.

What to do with this

If you're already paying for Claude Code and watching it wave its arms at everything that isn't a code file, the fix is four lines of JSON:

{
  "mcpServers": {
    "spatio": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.spatio.app/mcp"]
    }
  }
}

Drop that into your client config, sign up at spatio.app, and your agent stops being a savant with no hands.

Matt