Skip to Content
Tares

Can I try an AI SRE on my laptop without touching production?

Yes, Tares ships a bundled demo system that stands in for production, so you can run the whole alert, trigger, agent and finding loop on your laptop. The demo has a small api-server with a fault switch, Prometheus with three alerting rules, and a traffic generator. You cause an incident on purpose, and Tares wakes an agent that writes its diagnosis onto the timeline. Nothing in your real environment is involved.

How it works

The demo stack is one compose file with three parts:

  • api-server: exposes Prometheus metrics and request logs, and has a fault switch you use to cause incidents.
  • Prometheus: scrapes the api-server and evaluates three alerting rules, HighErrorRate, HighLatency and DependencyDown.
  • Traffic generator: keeps healthy traffic flowing so the timeline has something to show.

A demo catalog wires Tares to that stack. It creates three sources, all keyed by the same service label: demo_metrics (polled from Prometheus), demo_logs (the api-server container’s logs) and demo_alerts (the alerts Prometheus fires). Because all three carry service, Tares builds one timeline for api-server with metrics, logs and alerts on one clock.

The catalog also creates one trigger, incident, and one Tares agent, incident-first-look. Prometheus keeps owning alerting. Tares ingests what fired and correlates it with the evidence. The trigger fires when an alert event arrives, and it wakes the agent. The agent reads the correlated timeline, ties the failure to specific evidence lines and writes a finding back onto the timeline.

The built-in agent needs an Anthropic API key. You also need Docker running for the demo stack, and uv or pipx to install Tares.

Set it up

This is the catalog path. It starts Tares already seeded with the demo wiring. For a browser-only route, run tares up, open http://127.0.0.1:8787, go to Projects, pick the AI SRE demo template and click Start.

  1. Start the demo system you will monitor:

    curl -O https://raw.githubusercontent.com/glassflow/tares/main/demo/docker-compose.yml
docker compose up -d

  2. Wait about 10 seconds, then confirm it is alive:

    curl -s localhost:8080/api/stats                  # {"ok": true, ...}
curl -s 'localhost:9090/api/v1/query?query=up'    # prometheus is scraping

  3. Install Tares:

    uv tool install tares          # or: brew install glassflow/tap/tares

  4. Download the demo catalog, export your key and start Tares seeded with it:

    curl -O https://raw.githubusercontent.com/glassflow/tares/main/demo/catalog.demo.yaml
export ANTHROPIC_API_KEY=sk-ant-…
TARES_CATALOG=catalog.demo.yaml tares up

    The catalog only seeds an empty instance. If you already ran tares up in this data directory, start on a fresh one with TARES_CATALOG=catalog.demo.yaml tares up --data-dir ~/tares-sre.

  5. Open the console at http://127.0.0.1:8787, go to Explore and pick api-server. You see metrics, logs and alerts merged on one timeline.

  6. Cause an incident from the project page with Cause an incident, or from a shell:

    curl -s -XPOST localhost:8080/demo/inject -H 'content-type: application/json' \
  -d '{"scenario": "error_spike"}'

  7. Within about 30 seconds the chain runs on its own. Prometheus’s rules have a 15 second for:, then Tares polls the alerts. Watch HighErrorRate fire, the incident trigger fire, and incident-first-look write its finding. The finding appears on the project Overview under What the agents found and on the api-server timeline in Explore.

  8. Optional: start tares mcp in a second shell and connect your MCP client. Ask it what happened to api-server, and it answers from the evidence and the finding.

The full walkthrough is in Build an AI SRE, and the five-minute install is in the Quickstart.

The demo path assumes the local install, because its logs source tails docker logs on your machine. That does not work from inside the Tares container, so if you run Tares in Docker, pick Your own source instead.

What you get

  • A working AI SRE on your laptop: alert, trigger, agent and finding, all running without paging anyone.
  • A correlated timeline for api-server, with a diagnosis that names what broke, since when, the likely cause tied to evidence lines, and a next action.
  • Three scenarios to try: error_spike, latency and dependency_outage. Roll back with Clear the fault on the project page, or send {"scenario": "clear"} from the shell. The alerts resolve and a resolved event lands in the timeline.
  • A loop you can see close. Ask your connected MCP client the same question before and after the incident, and it starts from the previous conclusion instead of from scratch.
  • A clean exit. Stop tares up and tares mcp with Ctrl-C, run docker compose down, and delete the data directory for a clean slate.

When you are ready, the demo sources are ordinary configuration. You recreate them against your own stack, add a webhook source for deploys, rebuild the triggers and pick who gets woken.

When something else fits

  • If you have no Docker on the machine, the demo stack cannot run. Add a real source through the console instead, as the Quickstart shows with a GitHub repo.
  • If you want to see Tares on your own data rather than injected faults, skip the demo and follow the last step of Build an AI SRE to point it at your real systems.
  • If you only want to read evidence interactively, you can connect an MCP client without the trigger and agent.

Still stuck? Get help

Last updated on
Quickstart