Changelog
Getting Started

Installation

Clone the repository, boot the five-service stack with Docker Compose, and confirm the platform is healthy.

This page takes you from nothing to a running teaspill platform: the five infrastructure services, plus the reference deployment's demo agents, all on your machine.

Prerequisites

  • Docker with the Compose plugin (docker compose, not the legacy docker-compose).
  • Node.js 20.19 or newer — Node 22 recommended.
  • pnpm 11 (the repository pins 11.13.0; corepack enable gives you the right version automatically).
  • An Anthropic API key — optional, but without one the demo agents won't be served and the quick start's researcher can't call a model.

Install

Clone and install

teaspill ships as a pnpm workspace — the platform, the SDKs, the CLI, and the reference deployment all live in one repository.

git clone https://github.com/everynow-dev/teaspill.git
cd teaspill
pnpm install

Build the packages and service bundles

The gateway and the reference deployment run in Docker from self-contained bundles, built once up front:

pnpm -r build
pnpm --filter @teaspill/gateway bundle
pnpm --filter @teaspill/reference-deployment bundle

Configure the environment

Every variable has a working default — .env only needs the dev API key, which lets services (and you) register and issue commands through the gateway:

cp .env.example .env
echo 'GATEWAY_BOOTSTRAP_API_KEY=tsp_local_dev_only' >> .env
echo 'TEASPILL_API_KEY=tsp_local_dev_only' >> .env
# optional — enables the demo agents:
echo 'ANTHROPIC_API_KEY=sk-ant-...' >> .env

The bootstrap key is a development convenience: it works before any real key exists. For anything beyond local dev, mint real keys with teaspill keys create and drop the bootstrap — the Auth & API keys guide covers both.

Boot the stack

The previous step built the teaspill CLI into the workspace. Alias it once per shell and point it at your dev key now — the richer boot loop below and the checks in the next step both use it:

alias teaspill="node $PWD/packages/cli/dist/index.js"
export TEASPILL_API_KEY=tsp_local_dev_only

The base compose file runs the infrastructure; the overlay adds the reference deployment's two services on top:

docker compose -f docker-compose.yml -f docker-compose.overlay.yml up -d --build

The first boot builds three images and pulls four, so it takes a few minutes. Prefer a richer dev loop? teaspill dev wraps the same boot with a gateway health wait, deployment registration with retries, and tailed logs:

export COMPOSE_FILE=docker-compose.yml:docker-compose.overlay.yml
teaspill dev --deployment http://agent-loop:9080 --deployment http://executor:9081

Check that it's up

Well done — the platform should now be running. The gateway answers on port 8787, and the teaspill alias you set above lists what's running:

curl http://localhost:8787/health
# {"ok":true}

teaspill agents ls

An empty list is the correct answer on a fresh stack — nothing has been spawned yet. If both commands succeed, everything is wired. (The CLI reference covers every command and flag.)

What you just started

The compose stack runs five infrastructure services: the gateway (port 8787 — the single front door for your app, your UI, and the CLI), Restate (the coordination core that runs your agents durably), Postgres (the catalog: the registry of every agent), Electric (live sync of the catalog into browsers), and the durable streams server (the history store behind every agent's timeline).

The overlay adds the two services you deploy when you build your own system: an agent-loop (here, the reference deployment's demo and test agents) and an executor (which hosts sandboxed workspaces for agents that run commands). The architecture overview explains how the pieces fit; Self-hosting covers running this stack for real.

One networking rule bites everyone eventually: a service running on your host (like the quick start's agent process) must register itself as http://host.docker.internal:<port> — never localhost. Restate dials registered URLs from inside its container, where localhost means the container itself, so a localhost registration succeeds and then every invocation fails. The Self-hosting guide has the full story.

Next steps

The stack is up — now make it do something. The quick start builds your first agent and streams its timeline into your browser.