Skip to Content
TaresIntroduction

Introduction

Tares is the open-source platform for always-on AI agents. Chat agents wait for a prompt. Tares agents wait for an event: every event from your systems lands on one timeline per thing, a trigger wakes an agent the moment it matters, and the finding it writes back is there for the next reader.

Using a coding assistant? Start with AI resources, a page written for it.

What is Tares?

Tares sits between the systems you already run and the agents you want working on them.

  • Connect anything that emits events. Logs, metrics, alerts, deploys, commits, database rows, webhooks. A connector turns each one into events; nothing to change on the source side.
  • One timeline per thing. Every event that concerns a service, a repo, a customer or a job is merged into one time-ordered timeline for it. An agent asks “what happened to checkout?” once and gets the whole picture, across all sources.
  • Agents that run on what happens. Triggers watch the timelines. When a condition fires, Tares wakes an agent with the correlated timeline already in hand, over MCP or a webhook, or runs a Tares agent in-process.
  • Findings that stay. What the agent concludes is written back onto the timeline as an event. The next reader, human or agent, starts from the last conclusion instead of from scratch.

Tares is MIT licensed, runs on your machine or your server, and stores everything in one local DuckDB file. No external database, no broker, no telemetry.

Explore's Agent view: one correlated read for a service, exactly as an agent receives it

How it works

Four steps, each one a page in the console.

  1. Sources bring events in. Poll connectors (Prometheus, GitHub, Postgres, Docker logs) fetch on an interval; push connectors (OTLP, Alertmanager, Vercel, webhooks) receive over HTTP. Each event keeps its original payload. Connectors
  2. Views join sources on a shared key. A view keyed by service reads logs, metrics, alerts and deploys for api-server as one timeline. Reads without a view still work; a view narrows and names them. Concepts
  3. Triggers watch a view and fire on a condition: an alert lands, an error rate crosses a line, a commit touches a path. A cooldown keeps one incident from firing a hundred times. Triggers
  4. Agents get woken. An external agent receives the timeline over a webhook or reads it over MCP; a Tares agent runs inside Tares on your prompt and writes its finding back. Tares agents, Connecting agents

Underneath, one daemon (taresd) serves the HTTP API and the console, and tares-mcp exposes the read and watch tools to any MCP client.

Two ways to build

Keep the agent you have (Claude Code, Cursor, Codex, your own loop) and give it one MCP call that returns the correlated history of anything. Best when you already run an agent and want it to stop stitching ten tool calls together.

Your agent, better informed

Write a prompt, attach it to a trigger, done. Tares runs it in-process when the trigger fires, reads the timeline, and writes a finding. Best when nobody is at a keyboard when it matters.

A Tares agent on a trigger

The two combine: a Tares agent writes the first look, your coding agent picks it up from the timeline when you sit down.

Key capabilities

  • Correlated reads. read(selector, window) returns any entity’s timeline across all sources; query(view, ...) reads through a saved view; derive lets an agent author a view of its own.
  • Triggers and delivery. Conditions over live data, cooldowns, delivery to webhooks, Slack channels and Tares agents, with every attempt logged and retried.
  • Tares agents. Prompt plus trigger; runs on your Anthropic key, read-only by default, with external MCP servers opt-in per agent. Each run is metered.
  • Findings and memory. Conclusions become events on the timeline; remember writes observations back for the next read.
  • Console and Ask. Sources, Explore, Views, Triggers, Agents, Deliveries, and Ask, an assistant over your own data (⌘K).
  • Slack. Subscribe a channel to any trigger; ask back with /tares ask.

Choose your path

Install, connect one source, connect your agent. About five minutes.

Quickstart

Describe what you need; the assistant proposes the sources, views, triggers and agent, and you confirm each one. The result is an ordinary project.

Build with Tares

Start from a Tares template, or assemble a project from objects you already have.

Projects

The hosted version: sign up, connect sources, same timeline and MCP endpoint.

Tares Cloud

Developer tools

The tares CLI starts and inspects an instance:

uv tool install tares      # or: pipx install tares
tares up                   # daemon + console on http://127.0.0.1:8787
tares status               # readiness checklist and the one next step

Your coding agent can do the whole setup for you. Paste this into Claude Code, Codex or Cursor:

Run npx skills add glassflow/tares --skill tares and use the tares skill to install Tares and connect it to this agent.

Full reference: CLI, HTTP API.

An alert fires; the agent reads the service’s whole timeline and writes the diagnosis before anyone opens a dashboard.

AI SRE

Commits land; when a change matters to the team, the agent opens a pull request against the shared context repository.

Shared code context

Failed jobs, sandbox runs, voice calls: each gets a timeline, a trigger on failure, and a finding that says what broke.

Anything with a failure mode

Need something Tares doesn’t do yet?

Custom connectors, missing features, or questions about Tares Cloud: email help@glassflow.ai or book a call . We’re building against real use cases and reply quickly. More ways to reach us on the Help page.

Last updated on
Quickstart