Agents

The whole cloud, drivable by an agent.

Because the project is files and every operation is an explicit command, a coding agent can stand the backend up, verify it, publish it, and read back what happened — the same lifecycle you drive by hand.

Get started →Explore the CLI

snoozestack/

$ snoozestack check --json

{ "valid": true, "files": 18 }

$ snoozestack preview

Files stay authoritative

Automation edits the project you review; it can't invent a setting that lives nowhere.

MCP follows the CLI

Agent tools share the schemas, errors, and dry runs of the command-line workflow.

The docs come with it

An agent reads these pages over the same connection, so it follows the patterns rather than guessing.

Agents, running

local development

connected · any AI client

list_roundstool

create_roundtool

get_usertool

log_scoretool

list_coursestool

A project an agent can actually read

The backend is a folder of committed files rather than a console someone has to click through, so an agent proposes changes the same way you do — as a diff you review, with the configuration sitting next to the code that depends on it.

Every resource is declared in one manifest it can validate
Validation reports the offending file and line, not a stack trace
Nothing important lives in a setting the repository can't see

terminal

$ snoozestack check --json
{ "valid": true, "files": 18 }

$ snoozestack preview
  ok    Deploying preview         preview-@you building
  ok    Waiting for the preview   ready after 41s

  ╭─ preview-@you is ready ──────────────────────────────╮
  │   preview  https://preview-you-my-app.snzzz.com/     │
  ╰──────────────────────────────────────────────────────╯

Write, then verify — the loop that finishes work

The useful part isn't automating the clicking. It's that an agent can observe what it did: run the project locally, call the function it just wrote, read the signals back, and correct itself before handing anything over.

The CLI for you and CI, MCP for AI clients, one API underneath
Tools are annotated read-only or destructive, so clients can confirm
These docs are served over the same connection the tools are

~/.claude.json

"snoozestack-my-app": {
  "type": "http",
  "url": "https://snoozestack.com/api/mcp/my-app",
  "headers": { "Authorization": "Bearer sb_mcp_..." }
}

Built for apps people actually use

What you build with Agents.

Build the backend alongside your app

While you are building the app, your agent defines the table, writes the function, sets the key, and publishes the backend in the same pass as the client code.

Debug what it just shipped

Deploy, call, read the logs, fix, redeploy. Your agent iterates on real output instead of asking you to reproduce or explain the error.

Keep every app reproducible

Start another isolated project for the next app idea, restore the same project on a new machine, or create a named preview before you share it. Each one uses the same operations you run by hand.

You and your coding agent share the same project model and operational interfaces.

Why SnoozeStack →

More of the platform