Tares
OfficialConnector that brings GitHub activity onto repository timelines, and lets agents work with repos: the software-factory crew opens pull requests, reviews changes, and merges once CI is green.
Connector that ingests Prometheus metrics and alerts as events, correlating them onto a service's timeline so an agent can read the whole history and write a diagnosis when an alert fires.
Connector that streams Vercel deployment events onto a project's timeline so agents can wake and react when a deploy happens.
Tares
Always-on AI agents, as a Software Factory or an AI SRE.
Tares comes in two editions, and each Tares you create is one of them. As a Software Factory, a crew of Claude Code sessions takes your projects from a spec to pull requests merged on main. As an AI SRE, agents watch your services and tell you what broke and why. Both keep what they decide (plans, tickets, reviews, incident notes, your answers) for the next reader, human or agent.
Software Factory
You plan a project with Claude Code. A crew of Claude Code sessions on your machine builds it: an orchestrator hands out the tickets, builders open pull requests, a reviewer holds every change to a fixed bar, and a change merges once it passes review and CI. You talk to one session, and only for the decisions that are yours.
Plan once: a spec, milestones with acceptance checks, and tickets with a working doc each, kept on Tares, Linear or GitHub Issues.
Build in parallel: one crew serves every project, with a builder per milestone and repo.
See it all in one place: the console shows what waits for you, each project's progress, the tickets, the pull requests in review and the crew at work.
Nothing is lost: tickets, reviews, the crew's calls and your answers live on Tares, so the crew carries on after a restart and you can check every choice it made.
Work as a team: each person runs their own crew on the same Tares, with project leads, private projects and repo owners the spec asks instead of guessing.
uv tool install tares # or: brew install glassflow/tap/tares
tares login # sign in to your Tares Cloud workspace (or run `tares up`)
tares factory crew up # start the crew; the first run asks how far it may go
tares factory spec "what you want to build" # in your repo: plan the project and hand it overNeeds Claude Code (signed in, on a plan with background sessions) and gh with write access to your repos.
→ Get started, The console, Teams, A project, end to end
Related MCP server: Claude Code Toolkit
AI SRE
Connect your logs, metrics, alerts, traces and deploys. Tares puts every event about a service on one timeline, a watcher checks every service on a schedule, and when something looks wrong an investigator writes an incident note: what is failing, the likely cause, the evidence and the next step. The note lands in Slack, where your team takes it, resolves it, or says whether it was worth raising.
uv tool install tares # or: brew install glassflow/tap/tares
tares up # choose 2) AI SRE; console on http://127.0.0.1:8787→ Get started, Tutorial: build an AI SRE
Tares Cloud or your own machine
Tares Cloud is the managed version: create a Software Factory or AI SRE workspace, and it is ready in about a minute. Team features are included.
On your own machine, tares up runs the same open source Tares: one daemon and one DuckDB file, with no external database, no broker and no telemetry. To run it on your private cloud for a team, use the enterprise version: write to help@glassflow.ai.
Why Tares
A record that outlives the session. Plans, tickets, reviews, findings and decisions stay on Tares for the next reader.
Agents that run on events, not prompts. Work continues while you are away, and you are asked only what is yours to decide.
One read instead of ten tool calls. An agent asks about a service once and gets its correlated history across every source.
Bring your own agent. Claude Code, Cursor, Codex or your own loop, over MCP. Any model provider for Tares's own agents.
Learn more
the crew, planning, tickets, the console, teams and commands | |
connecting your data, watching, incidents, services and runbooks | |
the engine underneath: connectors, timelines, triggers, agents and projects | |
Docker, servers, TLS and auth | |
for coding assistants: Markdown endpoints and instructions to paste |
Feedback
Bug reports and ideas are welcome via GitHub issues or help@glassflow.ai.
License
MIT. This licence covers everything in this repository except directories named ee, which are under the licence in ee/LICENSE. Without an enterprise licence key, a self-hosted Tares runs for one person; see Enterprise licence.
Available Tools
83 toolsadd_checkA
Record a check you ran on a ticket: the exact command, what it showed (result), the
commit it ran on, and, for a test you added, broke_test: the test you saw fail when you
broke the code it covers (then pass again once restored). One line goes into the Checks part
of the ticket's working doc; the rest of the doc is untouched. Record each check after you
run it, never one you did not run: the reviewer compares them with your session. Several
checks you ran back to back go in one call: more takes the others as
[{command, result, commit, broke_test}, ...].
Inputs: result (required), ticket (required), command (required), more, +3 more. Returns: result
add_grantA
Keep one grant: words are the person's own words, quoted exactly as they said them
(never your summary); Tares adds today's date. kind is team (every project; all is the
old name), project (this project only, name it in project) or personal (what may run on
the person's own machine, for the key's own person). Without kind, a project makes it a
project grant and no project a team grant. areas lists the GitHub repos (owner/name) a
project grant reaches into, and needs an enterprise licence: the grant then waits, not in
effect, until each repo's area owner (other than the giver) calls consent_grant. A project
grant from someone who is neither the project's lead nor an admin also waits for the lead (an
admin, when the project has none). Without a licence a grant takes effect at once. scope is
the older name of kind. Only the person's own session or the orchestrator, relaying the
person verbatim, may add one.
Inputs: words (required), kind, areas, scope, +1 more. Returns: result
add_to_globalA
Add one line to a doc every project shares: doc is agents (the AGENTS.md for all
projects: a rule every session should follow, e.g. "always build on a branch, never commit
to main") or memory (a fact or preference that holds across projects, e.g. "the household
uses euros"). Ask the user first, and add only what holds beyond this project; a project's
own rules go in its own AGENTS.md. A line already there is not added twice. scope is team
(the default: the docs every person shares) or personal (the caller's own AGENTS.md or
memory, read only by them: a preference of theirs that is not the team's).
Inputs: doc (required), line (required), scope. Returns: result
assign_ticketA
Give a ticket (T3, its id, or its Linear or GitHub identifier such as GH-12) to the station that works it, by the station's name (for example shop-build-m1). Only the orchestrator, or the person's own session, assigns. A ticket with no stage yet starts at todo.
Inputs: holder (required), ticket (required), project. Returns: result
assumeA
Record an assumption you made so the work does not block: the question the plan did not
answer, the choice you made, why, the tickets it touches (T3, ...), and who it
affects. Returns its number (A1, A2, ...): tell the orchestrator that number in one line and
carry on. The orchestrator confirms open assumptions with the person once per milestone.
Never use this for what must go to the person directly (prod deploys, secrets, money, new
contacts, deleting data).
Inputs: why (required), choice (required), question (required), affects, +2 more. Returns: result
attach_working_docA
Link a working doc (write it first with write_doc, kind working) to a ticket, by the
ticket's Tares id, Linear identifier or GitHub identifier (GH-12). Works for tickets in
Linear or GitHub too: the working doc stays in Tares.
Inputs: doc (required), ticket (required), project. Returns: result
builder_briefA
Start every ticket here, and again after a revive: one read with where the ticket stands
(stage, holder, PR, verdict), its working doc, its milestone and acceptance checks, the state
of what it depends on, the project's AGENTS.md (it wins over the generic flow) and the shared
one, open assumptions and desk questions on it, and where you left off (checks recorded,
Codex, earlier review rounds, the crew's latest messages). start=True also moves a ticket
that has not been started to doing, so starting a ticket is this one call; a ticket already in
review, changes, blocked or merged keeps its stage.
Inputs: ticket (required), start, project. Returns: result
catalog_describeA
Describe one catalog entry in full: schema (event types + typed fields, inferred from stored events), freshness, lineage, and sample records. Handles look like source:logs or trigger:error_spike. Use this to discover label names before creating a trigger or reading an unfamiliar source.
Inputs: handle (required). Returns: result
catalog_listB
List available sources, triggers and projects.
Inputs: no named parameters. Returns: result
create_projectA
Create an empty Tares project for a piece of work you are about to spec, and tie this
session to it. name is the project's handle (unique on Tares); goal is one line saying
what it is for. Then write its docs with write_doc and its tickets (write_ticket; when they
live in Linear or GitHub, link_tickets first).
Returns the project's id and name.
Inputs: name (required), goal. Returns: result
create_sourceA
Create a data source so Tares starts ingesting it immediately (no restart). config is
the connector's config (see list_connectors / discover_source); push connectors ignore poll.
project is the project id the source joins (default: the default project); other projects
can use it too. Returns {ok, name} or an error detail. After creating, use list_sources to
watch it ingest and catalog_describe("source:") to see its labels.
Inputs: name (required), config (required), connector (required), poll, +1 more. Returns: result
create_triggerA
Create a trigger: a condition Tares evaluates continuously over one or more sources; when
it trips, subscribed agents are woken with the correlated timeline. sources names the
sources it watches (at least one). filters [{field, op, value}] (ops: eq, neq, in (a list), contains, gt,
lt, gte, lte) narrows them. key_field is the entity label (default: the primary label of the
first source). condition is {aggregate: any|avg|count|max|min|sum, field: numeric label to
aggregate (omit for count), predicate: e.g. '> 1.0' / '>= 5' / '== 0', window: detection
window e.g. '1m'}. emit is {kind: what a firing is called e.g. error_spike, context_window:
timeline the woken agent receives e.g. '15m'}. project is the project id the trigger belongs
to (default: the default project); its sources join that project. description (optional)
says in one plain line what wakes it, phrased to follow "When", e.g. "an alert fires in the
checkout service"; the project page uses it instead of the rule's own wording (at most 160
characters, one line). catalog_describe a source to confirm its labels first. Wire agents
to it with subscribe().
Inputs: name (required), sources (required), condition (required), emit, +5 more. Returns: result
crew_projectsA
The projects handed to the crew, oldest first: each with its repos (path on this
machine, GitHub name) and the tickets and open PRs of each, the autonomy it was handed
over at when stricter than the crew's, tickets done of all, and the milestone it is on. The
orchestrator works from this list: a project here with no builder is one to start. Projects
the person said are done are not in it (finished lists them apart). releasing lists the
projects the person took back from the crew (tares factory session <project>) that still
wait for the orchestrator to stop their builders (holders) and call release_project; they
are no longer the crew's to work on.
Inputs: no named parameters. Returns: result
decide_assumptionA
Record what the person said about an assumption (A3): state kept or overturned (or open
again), words the person's own words, required when overturned. Only the orchestrator, or
the person's own session, may. Answering a batch on the desk does this for you.
Inputs: state (required), assumption (required), words, project. Returns: result
desk_addA
Put a question for the person on the desk (one desk for every project; numbered D1,
D2...): the question, your recommendation and why, the options, two lines of context, what
it blocks (tickets, stations), whether it blocks, and who asked. to is the person it is
for (a person id or an email): it shows in their my_work, and only what they typed in their
own sessions answers it. Left out, it goes to the assignee of the first ticket in tickets
that has one, else the project's lead, else the person whose key this is. For the batch of
assumptions to confirm once per milestone, pass their numbers in assumptions. Then ask the
person in your session, one item at a time, blockers first. Only the orchestrator writes
the desk.
A permission a station was refused: station its name and command the exact command it
was refused, verbatim as it reported it; recommendation the grant in plain words (which
station may run what, where). The person can allow it with one click in the Tares console;
the crew's watch then restarts that station with the grant in its settings.
Inputs: why (required), question (required), recommendation (required), to, +10 more. Returns: result
desk_answerA
Record the person's answer to a desk item (D3). words is their reply exactly as they
typed it, never your summary: Tares looks for it in the recorded sessions of the person the
item is for (any station, any session of theirs). If it is not there yet, you get a
retryable error: recordings can take a minute to arrive, so try again after the next sync.
Nothing is recorded until the words are found. A reply of one letter ("B") is passed as
is: Tares maps it to that option. choice the option it picks, as the option's full text
(or, when they chose none, their own answer in a short sentence): on an item with options
every decision records one, and free words that name no option are refused (TR-1018). standing only when they
said it holds from now on ("always fine for staging"); with scope all it holds for every project.
A standing answer that matches becomes a grant given by that person: grant_kind project
(the default; with scope all, a team grant, which needs an admin) or personal (for their
own machine). A project grant that reaches into repos other people own waits for their
consent (grant says what it waits for). For an assumption batch: kept the
assumptions they keep, overturned {A3: their words}; open a follow-up ticket for each
overturned one.
Inputs: item (required), words (required), kept, scope, +4 more. Returns: result
desk_listA
The desk: open questions (or answered, withdrawn) across every project, blockers
first, then oldest. mine keeps the ones addressed to the person whose key this is. Ask the
first one.
Inputs: mine, state, project. Returns: result
desk_withdrawB
Take a question off the desk when it no longer needs the person (answered by events, or no longer relevant), saying why.
Inputs: item (required), reason (required). Returns: result
discover_dockerA
Scan the local Docker environment and get a list of proposed sources (one per container's
logs, plus a detected Prometheus). Each item's config is ready to pass to create_source.
Inputs: no named parameters. Returns: result
discover_sourceA
Introspect an upstream and get a proposed source config — no commitment. Works for
connectors that can introspect: e.g. prometheus given {"url": "http://..."}, or github given
{"repo": "owner/name"}. The returned proposed_config can be passed straight to create_source.
(Use list_connectors to see which connectors support discovery.)
Inputs: config (required), connector (required). Returns: result
finish_projectA
Mark a project done, once the person said so. Ask them first on the desk ("Is
done? Tickets all merged, milestones checked."), record their answer with desk_answer, then
call this with that item (decision, D). Tares keeps their words, sets the project done
and takes it off the crew's work list; a later hand-over opens it again. Refused while a
ticket is open. Only the orchestrator may. Returns how many projects the crew still holds:
with none left, ask the person on the desk whether to stop the crew (tares factory crew down
in their terminal).
A person's own session (tares factory session, not a crew station) passes words instead:
what the person typed when they said it is done, copied exactly. That also finishes a project
the crew never held.
Inputs: project (required), words, decision. Returns: result
get_crew_settingsA
The tares-factory crew's settings for every project: autonomy (L3-review: the person
approves each merge; L4-ship: Tares merges after the review gate passes and CI is green),
releaser (whether the crew runs a releaser; without one a ticket ends at merged),
release_profile, prod_pattern (what counts as prod), challenger (builders run the
Codex challenger), builders_max, claude_update (whether the watch moves stations onto a
new Claude Code; on unless false). Unset ones are null: ask the person, one at a time, with
a recommendation. These are the caller's own settings where they have set one, else the team's
default. kit.frozen is null while the crew follows the plugin checkout, else
when and by whom the person froze it (tares factory crew freeze): the watch then moves no
station onto a newer kit. Read only here; the person freezes and unfreezes from the CLI.
idle_wake (on unless false): the factory's watch wakes you with a message when
you have work and holds your liveness tick, so you arm no schedule of your own. pace (null or
false: off): when true the watch slows the crew before the plan's limits: no new builders, a
45-minute tick, and builders wait near the 5-hour limit; its notes to you say what to do.
docker_cleanup (on unless false): once a day the watch removes Docker's leftovers on the crew
machine (stopped containers, old build cache, images unused for 7 days; never volumes), and a
heavy command cleans up first when the disk is low. docker_keep lists image names it never
removes.
Inputs: no named parameters. Returns: result
get_docA
One of the project's docs, with its markdown body. A doc over 12,000 characters comes as
its headings (each with its size) and the start of its first section, not whole:
section="<heading>" reads one section (a heading of the doc, any case, with or without
its #), section="all" the whole doc. A shorter doc comes whole unless you name a section.
Inputs: id (required), project, section. Returns: result
get_integrationsA
Which integration each of the factory's seven slots uses (tickets, review, ci, memory,
monitoring, guardrails, runtime): its name and title, whether the factory's choice, the
project's own or the built-in default applies (source), and reason when a stored choice
was passed over. Pass project to see what applies to that project; leave it out for a
builder station's own project, or the factory's choice outside one. Never returns an
integration's settings or secrets.
Inputs: project. Returns: result
get_skillC
The instructions of one of the project's skills, as markdown.
Inputs: name (required), project. Returns: result
get_stationC
One station with its current session and the earlier sessions that played it.
Inputs: name (required). Returns: result
get_ticketA
One ticket, by its Tares id, its number (T3), its Linear identifier (for example
ENG-12) or its GitHub identifier (for example GH-12), with the body of its working doc, who
holds it and where it stands, who it is for (assignee, or assignee_raw when that person is
not on this cell), its pull request as GitHub has it (head, CI, the reviewer's verdict, merged), its history, and the
crew's messages about it: everything you need to work on it.
Small by default: a working doc over 4,000 characters comes as its Goal, Steps and Progress
with working_doc_sections (every heading and its size; section="<heading>" reads one,
section="all" the whole doc), the latest 8 messages and checks and the first 5 of its
decisions (this ticket's first; messages_total, checks_total count them all,
decisions_total the decisions the ticket carries; list_decisions has the rest), and reviews with only their open findings in words. detail="status" is only where it stands
(stage, holder, PR, verdict), for a tick; detail="full" is everything, uncut. Each answer
carries a fingerprint: pass it back as since and an unchanged ticket answers
{"unchanged": true} alone.
Inputs: ticket (required), since, detail, project, +1 more. Returns: result
hand_overA
Hand a specced project to the crew: Tares records it with every repo it spans, who handed
it over and to which crew, and the orchestrator picks it up from Tares on its next tick.
repos is one {path, name} per repo:
path the absolute folder it is checked out in on this machine, name its GitHub repo
(owner/name), the repo that holds the plan first. A later call adds repos, never replaces
them. A folder is kept for your crew only: a teammate's crew building the same project hands
over its own clone's folder with the same name. autonomy only when the person wants this project stricter than the crew
(L3-review: every merge waits for their yes). repo (one path) is the older form. Then
send your own crew's orchestrator (the reply names it) a [TF:SHIP] message with
SendMessage so it starts now rather than on its tick. If your crew is not running (the
reply says so), tell the person to run tares factory crew up first. Other people's crews
pick up their own tickets on their next tick. Needs a key with a person. A project kept for
later (set_later) starts with it. A guardrail that blocks refuses the hand-over with its reason;
one that only warns is shown in the reply.
Inputs: repo, repos, project, autonomy. Returns: result
hand_project_to_crewA
Hand a planned project to the crew to build. project is its name or id. repos is one
{path, name} per repo the project changes: path the folder it is checked out in on this
machine, name its GitHub repo (owner/name), the repo that holds the plan first. Pass
autonomy only when the person wants this project stricter than the crew, for example
L3-review, where every merge waits for their yes. Says whether a crew is running and what to
send it next.
Inputs: project (required), repos, autonomy. Returns: result
how_is_projectA
How one project is doing, as its row on the home page shows it: where it stands, the
milestone it is on, tickets merged and blocked out of all, builders working, repos and when
it last moved. Then every open ticket with whose turn it is, as the console words it ("Ready
for you", "Checks failing", "Queued after T3"), the person's first, and how many are with
each: you, the crew, GitHub's checks, or waiting on another ticket. project is its name or
id.
Inputs: project (required). Returns: result
how_is_serviceA
How one service is doing, as its page shows it: its state in words, what it sends
(logs, metrics, traces, deploys), whether it is watched and by whom, when it was last checked,
its incidents and what the cell cannot see about it. service is its name. An unknown name
answers with the services there are.
Inputs: service (required). Returns: result
join_projectA
Join a project: Tares POSTs every firing of every trigger in the project to url (your
agent's webhook), the triggers added later included. The body carries dispatch_id, trigger,
project, key (the entity), fired_at, payload (the timeline) and run_ids (the Tares agents it
woke). Returns the subscription id.
Inputs: url (required), project. Returns: result
link_ticketsA
Tie the project to where its tickets live, integration "linear" or "github" (Jira is
not covered). link_fields holds only non-secret fields: for Linear project, the Linear
project's id, URL or name; for GitHub repo (owner/name or URL) and issue_label (default
tares:<project name>). The cell's own Linear or GitHub connection is used, so never pass a
key or a token (it is refused). Tares then keeps its ticket list in sync (about once a
minute) and reads it once now. After it, write_milestone and write_ticket create the
milestones and tickets in Linear or GitHub. Returns the link and the tickets found.
Inputs: integration (required), project, link_fields. Returns: result
list_assumptionsB
The project's assumptions, A1 first: the question, the choice, why, the tickets, and the
state (open: not yet confirmed; kept; overturned, with the person's words). state
narrows the list.
Inputs: state, project. Returns: result
list_connectorsA
List the connector types you can create a source with, each with its config fields, mode (poll | push), and whether it supports discovery. Read this first to learn what you can ingest and how to configure it.
Inputs: no named parameters. Returns: result
list_crewB
The crews as Tares sees them: one row per station (orchestrator, reviewer, releaser,
builders, helpers) with its state (working, idle, waiting, quiet, ended), the project it is
on, when it last spoke, the stations it started, and how many earlier sessions played it.
Each row names its crew, the machine the crew runs on and the person it belongs to: two crews
can have stations of the same name. With mine only the caller's own crews are listed.
Inputs: mine. Returns: result
list_decisionsB
What the person decided on the project, newest first: the question, their words, the
choice, whether it stands from now on and whether it matched what they typed (via
"console": they answered or allowed it in the console; a permission they allowed there
restarts that station with it). Follow them; relay them to stations by quoting the words.
The newest limit come (a last entry {"more": ...} says how to read older ones with
offset), each question cut to 200 characters, person as its name only, and choice left out
when it is the answer; detail="full" gives all of them whole, as before.
Inputs: limit, detail, offset, project. Returns: result
list_docsA
The project's docs in reading order (starting prompt, spec, plan, AGENTS.md, memory,
notes): id, kind, title, size. No bodies: read one with get_doc. kind narrows the list.
Working docs are left out unless kind="working" (a ticket's working doc comes with
get_ticket). Docs marked global (the AGENTS.md and the memory for all projects) belong to
every project: read them too, they hold the user's standing rules. At most limit docs;
a last entry {"more": ...} says how to read the rest.
Inputs: kind, limit, offset, project. Returns: result
list_findingsB
The findings recorded in the project, newest first: its Tares agents' and the ones
external agents recorded. entity and agent narrow them. Read them before concluding, so
you build on what is known instead of repeating it.
Inputs: agent, limit, entity, project. Returns: result
list_milestonesA
The project's milestones in order: name, goal, acceptance checks, check_results (each
check's n, for crew or person, and its latest result), how many tickets and how many are done, which are
ready, whether the milestone is finished and accepted, and crew_to_run (the crew checks not
recorded yet) and crew_failed / person_wrong (failed ones: open a ticket for each, where
the project's tickets live). Work one milestone at a time, in this order.
A finished milestone comes short (its goal cut, checks only counted, no check_results, the
rest as is); detail="full" gives every milestone whole, and a milestone's acceptance checks
are read that way.
Inputs: detail, project. Returns: result
list_peopleC
The people on this Tares: id, name, email, GitHub login and whether they are an admin.
Inputs: no named parameters. Returns: result
list_projectsB
List the projects you can work in: id, name, template and status. With a project key it is the one project the key belongs to.
Inputs: no named parameters. Returns: result
list_secretsA
The names of a project's secrets (TR-775): who set each and when, never a value. To use them,
run the command that needs them as tares factory with-secrets -- <command>, which sets them as
environment variables for that command only. Never print a secret, write it to a file, or pass
it on a command line. Only the project's members see this list.
Inputs: project (required). Returns: result
list_skillsA
List the project's skills: name and description. Load one with get_skill before relying on it, only when your task matches its description.
Inputs: project. Returns: result
list_sourcesA
List every configured source with its live health (status, events ingested, last error). Use it to confirm a source you created is actually ingesting.
Inputs: no named parameters. Returns: result
list_ticketsA
The project's tickets in plan order: id, label (the Linear identifier such as ENG-12, the
GitHub identifier such as GH-12, else T), title, status (todo, in_progress, done,
canceled), milestone, depends_on, the GitHub repo it changes (repo, owner/name, for a
project that spans several), whether it is ready (all it depends on is done) or which tickets
block it, who it is for (assignee_note: "assignee: Kiran" or "unowned (kiran@x.com is not on
this cell)"). Work the ready tickets in this order. Also says where they live: linear is
the Linear project and github the repo and issue label, each with when it was last synced
(null when the project does not use it); with both null the tickets live in Tares. Read one
with get_ticket to get its working doc.
Small by default: milestone (a name) and open=True (not done or canceled) narrow it, at
most limit tickets come back and within about 8,000 bytes (more says how to read the
rest with offset), and each ticket leaves out its link when they share one pattern
(ticket_url, with {label}), its working doc and its assignee object. detail="full"
gives every ticket with every field, as before.
Inputs: open, limit, detail, offset, +2 more. Returns: result
mark_incidentA
Change where an incident stands. incident is its id, as what_is_broken shows it. state
is on_it (you or the person is working on it), resolved (it is over) or open (nobody is on it
and it is not over). It is recorded under the key the caller uses, so a read-only key is
refused and the answer says so. So is a change the incident's state does not allow: a
resolved incident cannot go to on_it until it is open again. Returns the incident as it
stands now.
Inputs: state (required), incident (required). Returns: result
merge_readyA
May this pull request merge? One answer from the review gate, CI and the guardrails of
the project its ticket belongs to. pr is a PR URL or owner/repo#12. Returns ready
(true only when the PR is open, not a draft, the review gate approved its current head, CI
passed or the project has none, and no guardrail blocks), reasons (a sentence for each thing
holding the merge back; empty when ready), the head commit, and the review, ci and
guardrails answers. A bad reference, a PR no ticket has or a failed read comes back as
ready false with a reason. It changes nothing: it only answers; Tares's merge queue does the merging. project is accepted for
consistency with the other tools; the project comes from the pull request's ticket.
Inputs: pr (required), project. Returns: result
my_workA
What belongs to the person whose key this is, across the projects handed to a crew that
they can see: ready (their tickets that can start: nothing they wait on is open), in_progress
(their tickets a station holds, with the holder and stage), bouncing (those of them that
came back from review three or more times: count, ladder 3 or 5 and the last reason),
led_projects (projects they
lead, with the milestones whose tickets are all delivered: milestones_ready_to_check),
desk (the open desk items addressed to them) and spec_questions (the open questions a
spec asked them as the owner of a repo, always empty without an enterprise licence: answer each
with answer_question). crew
names your crew; empty means the crew this session belongs to. The orchestrator of a crew works from this, so it starts
only its own person's tickets. project (a name or an id) keeps spec_questions to that
project: question numbers restart in each project, so name it when you work on one. Empty
lists the questions of every project; a name or id you cannot see is an error 404 ("no
project 'x' you can see"), so name it exactly. Needs a key with a person.
Every answer carries a fingerprint. Pass the last one back as since on each tick: when
nothing changed the answer is {"unchanged": true} alone (keep the fingerprint you hold);
otherwise only the parts that changed come with a new fingerprint, same names the others, desk items you have already seen
come as their label and question (seen), and desk_closed lists the ones gone. Call it
without since after a compaction or a restart, to have everything again.
Inputs: crew, since, project. Returns: result
pick_upA
Pick the build up where an earlier session stopped. Call it first when you are told to work on a project and a ticket is already in progress (list_tickets says so), or when told to pick up. Returns the hand-over: the ticket with its working doc, what the previous session said last and the files it touched, the builders' notes and a checklist. It takes the build over (the previous session is marked replaced) unless that session may still be open: then it says so and does nothing; ask the person, and call again with take_over=true only if they say so.
Inputs: project, take_over. Returns: result
project_timelineB
What happened in the project, newest first: each firing with the runs it woke and their findings, and the findings recorded without a firing (external agents' among them).
Inputs: limit, project. Returns: result
readA
Read one correlated, time-ordered timeline of everything matching selector across all
sources, or only a project's sources, or only the sources you name. selector is a
{label: value} conjunction, matched with strict AND, e.g. {"repo": "frontend"} or
{"service": "api-server", "endpoint": "/login"}. An event matches only if it carries every
named label with that value, so adding a label narrows and removing one widens. Use this to
investigate any entity on the fly; once you know which sources matter, create_trigger() over
them. Set include_payload when the one-line summaries aren't enough and you need each
event's full lossless record: the return becomes JSON {timeline, events[]} where each event
carries raw. With a project key the read covers that project only, its findings
included.
Inputs: selector (required), window, project, sources, +1 more. Returns: result
read_global_docsA
The docs every project shares: the AGENTS.md for all projects (the user's standing rules) and the memory (facts and preferences that hold across projects), as markdown, then the caller's own rules and memory when they have any (they add to the team's; when they conflict, the team rule wins). Read them at the start of any work on a project and follow them; do not ask the user again for what they already say.
Inputs: no named parameters. Returns: result
read_grantsA
What the person allows the crew to do, in their own words with the date: the grants for
every project, the project's own when project is given, and your personal ones. Those in
effect come first; a project grant that reaches into another person's repo is listed as
waiting for that owner and is NOT in effect. Never act on a permission that is not here or
in the person's own words in your session.
Inputs: project. Returns: result
recallA
Ask the project's memory what it holds about a question, before you read the code base
from scratch. It answers with the lines of this project's memory and the shared memory that
share words with question, best first, each starting [project] or [shared]. Ask in plain
words ("how do tests start the dev database"); a line remember_for_project kept earlier is
found here. note says so when the cell's memory service did not answer and the Tares docs did.
Inputs: question (required), project. Returns: result
record_findingA
Record what you concluded about an entity (a service, a repo, a customer) in the project.
It lands on the entity's timeline next to the Tares agents' findings and in the project's
activity, under your key's name. finding is markdown; verdict one lowercase word (for
example rca or resolved); label the label the entity is a value of when it is not the
project's usual one (for example service). headline is one line (at most 100 characters)
saying what you found, and next_step what a person should do (empty when nothing needs
doing): both show on the project's Overview.
Inputs: entity (required), finding (required), label, project, +3 more. Returns: result
record_milestone_checkA
Record one run of a milestone's acceptance check (TR-1017): milestone its name or id,
n the check's number (1-based, as list_milestones shows), result pass or fail, note
the last lines of what it showed. Run a milestone's crew checks (for crew) as soon as its
last ticket merges and record every one; a fail is the crew's work (open a ticket for it).
Checks for person are the person's: they try them in the console, never record those.
Inputs: n (required), result (required), milestone (required), note, +1 more. Returns: result
record_reviewA
Record your review of a ticket's pull request, the same verdict you post to GitHub:
head the commit you reviewed, verdict pass, changes or block, verified what you ran
and what it showed, not_verified what you did not cover and why, findings
[{"severity": "P1|P2|P3", "file": "", "line": 0, "blocking": true, "text": ""}], and on a
re-review resolved marking each earlier finding {"F1": "fixed", "F2": "open"}. A pass
leaves no blocking finding open. Only the reviewer records reviews. When the cell holds a
GitHub App that can write to the repo, Tares also posts the review to the PR as the App (the
comment and the factory/review check run); the answer's github says what went up and,
when something did not, why: post that part with gh.
Inputs: head (required), ticket (required), verdict (required), verified (required), +4 more. Returns: result
recurring_findingsA
Kinds of finding that came back in several tickets of a repo (owner/name) in the last 30 days, with the tickets and examples. Check these first in a review.
Inputs: repo (required). Returns: result
release_projectA
The person took this project back from the crew (it is under releasing in
crew_projects): call this once every builder that held its tickets has stopped, pushed what it
had and written its progress, and has been retired. Tares clears the tickets' holders (stages,
pull requests and working docs stay) and the person's session owns the project from then on.
Then reply to the session that asked with [TF:RELEASED]. Only the orchestrator, or the
person's own session when no orchestrator runs.
Inputs: project (required). Returns: result
release_readyA
May this commit be shipped? Asks the project's guardrails at the pre_release hook. Returns
ready (false when a guardrail blocks, cannot be reached, or the project or commit is
missing), reasons (a sentence for each thing holding the release back), warnings
(shown, not blocking) and guardrails (each guardrail's decision). Call it before tagging or
deploying and stop when it is not ready.
repo is owner/name, milestone the milestone being shipped, merged_prs the pull requests
in it (owner/repo#12). It changes nothing.
Inputs: repo, commit, project, milestone, +1 more. Returns: result
rememberB
Write an observation back to Tares's agent-memory lane. It becomes a source like any other: joined into correlated reads, so what you learned this incident appears in the timeline next time the same key acts up. memory_type: observation | aggregation | decision.
Inputs: key (required), content (required), memory_type. Returns: result
remember_for_projectA
Keep one thing you learned about this project (for example "tests need the dev database running") in its memory, dated and signed; every session on the project reads it. A rule worth keeping for every project goes to the orchestrator instead (an FYI); only it adds to the shared memory.
Inputs: line (required), project. Returns: result
review_briefA
Start every review here: the pull request as GitHub has it (it says STOP when the PR is
merged or its head moved past head), the ticket and its working doc, the builder's checks
compared with its recorded session (unmatched first: check those yourself), Codex's
findings and the waivers to judge, earlier rounds and their open findings, assumptions and
decisions, what keeps coming back in this repo, and the repo map. known_map is the map
version an earlier brief in your context showed (its heading says "version "): when the
map is still that one it comes as one line. Leave it empty after a compaction or restart.
Then review to your own bar.
Inputs: ticket (required), head, project, known_map. Returns: result
review_queueA
The pull requests waiting for review across every project, in the order to take them:
those blocking their milestone first, then the longest waiting. Each says whether the
builder's Codex layer is clean and whether an earlier verdict is for an older commit.
The answer is {"fingerprint": ..., "queue": [...]}. Pass the fingerprint back as since:
when nothing in the queue changed (a new head, verdict or order counts; the minutes a pull
request has waited do not) it answers {"unchanged": true} alone. Leave since empty after a
compaction or restart.
Inputs: since. Returns: result
set_crew_settingsB
Save the crew's settings the person chose (only the ones given change). They are saved for
that person; on a single-user cell they are the cell's. A personal autonomy or challenger
can be as strict as the team's or stricter, not looser. clear names settings to unset, so
a person's own fall back to the team's. Only the person's own session or the orchestrator
may. idle_wake (on unless false) has the watch wake idle stations when they have work, instead of
each ticking on its own; false goes back to the fixed ticks. pace true slows the crew before the plan's limits are hit.
docker_cleanup false stops the daily Docker cleanup; docker_keep (image names, * as a
wildcard) replaces the list of images it never removes.
Inputs: pace, clear, autonomy, releaser, +8 more. Returns: result
set_laterA
Keep a specced project for later: the person's backlog, off their home until it is
started. Call it when the person says the project is for later, not to build now, and never
on your own judgment. later=False (or hand_over) starts it again. Refused for a project the
crew already has, and for a finished one.
Inputs: later, project. Returns: result
set_required_checksA
Set the commands a pull request of this project must have recorded as passing checks
when its CI is the local integration (the ci slot is local): the test and lint commands
from the project's AGENTS.md, exactly as a builder runs them. Replaces the list; an empty
list means the project requires none. For the project's lead or an admin, not a crew
station.
Inputs: commands (required), project. Returns: result
set_session_flowA
Mark this Claude Code session as running a named flow, e.g. "challenger" (a second model challenges your plan and every commit; Tares keeps the whole exchange and writes the session summary). Pass an empty string to clear it. Call it when the user asks for the flow at the start of a session. This tool only acknowledges: the Tares plugin sees the call in the transcript and marks the session on both the laptop and Tares.
Inputs: flow. Returns: result
set_stageA
Move a ticket you hold: stage is doing (you started), review (its PR is up: pass pr,
the pull request's URL), changes (the reviewer asked for changes), merged, or blocked (say
why in reason; Tares puts the ticket on the desk for a person, unless an item about it is
already open, and takes it off when the ticket moves on). Only the releaser marks a ticket shipped. A ticket held by another station
is refused; ask the orchestrator. For a ticket that lives in Linear or GitHub, also move it
there (Linear's own tools, gh for GitHub). Name your branch factory/ (factory/T3)
so Tares finds the pull request on its own too. Asking for review, pass the checks you ran
as checks ([{command, result, commit, broke_test}, ...]) instead of one add_check call
each; they are recorded before the stage moves.
Inputs: stage (required), ticket (required), pr, checks, +2 more. Returns: result
source_fieldsA
Profile a source's real fields from recent events: every candidate field with its coverage,
distinct count, and top values, plus which are already declared as labels/keys. Call this BEFORE
choosing labels for a source — a label's field MUST be one of these exact field names (never
invent one). The labels block echoes the source's current declared axes.
Inputs: name (required), limit. Returns: result
start_projectA
Start a new project for a piece of work the person wants built. name is its short name,
unique on Tares; goal is one line saying what it is for. It starts empty: spec it next
(the spec skill), then hand it to the crew with hand_project_to_crew. Returns the project's
id and name.
Inputs: name (required), goal. Returns: result
statsA
Counts per value of the label by over the project's sources, the last window against
the window before, largest change first. where {label: value} narrows the events counted,
sources narrows the sources. Use it to see what moved before reading one entity.
Inputs: by (required), top, where, window, +2 more. Returns: result
subscribeB
Register a webhook to be woken (pushed) when a trigger fires. Returns a subscription id.
Inputs: url (required), trigger (required). Returns: result
test_sourceA
Dry-run a source config without creating it: poll connectors do one live poll and return a sample; push connectors return their ingest endpoint. Use before create_source to check the config works.
Inputs: name (required), config (required), connector (required), poll. Returns: result
update_triggerA
Edit an EXISTING trigger in place: replace its sources, filters, key_field, condition,
emit and cooldown, and move it to another project when given. Create new triggers with
create_trigger(); this only updates one that already exists (renaming isn't supported, so
keep name the same). description left out keeps the current one, "" clears it. See
create_trigger for the shapes.
Inputs: name (required), sources (required), condition (required), emit, +5 more. Returns: result
what_happenedA
What happened to the services in a stretch of time, newest first: log changes, deploys,
alerts, checks, incidents and metric steps, each with when it was and what it was. service
narrows it to one service. window is how far back to look: 30m, 1h, 6h or 24h. The window
ends at around, an ISO time such as 2026-11-02T14:00:00Z (no zone means UTC), which is now
when left out. To see what led up to a moment, pass that moment as around.
Inputs: around, window, service. Returns: result
what_is_brokenA
What is wrong right now, as the AI SRE home page says it: the headline, whether anybody is watching the services and, if not, why and since when, and every open incident with its service, how long it has been open, who is on it, what is failing, the likely cause and the next step. Start here when the person asks what is broken, what is on fire or whether anything needs them.
Inputs: no named parameters. Returns: result
what_needs_meA
What is waiting for the person right now: the same list the home page shows under "Waiting for you", oldest first with the projects ready to close last, each with what it is, which project it belongs to and how long it has waited. Start here when the person asks what to do next or what is stuck.
Inputs: no named parameters. Returns: result
write_docA
Write a markdown doc into the project, or replace one when id is given. kind is one
of: start (the prompt a session that builds the project starts with: what to read first,
which ticket to take, how to work), spec (what is built and why), plan (milestones and
the order of work), agents (the AGENTS.md of the build: conventions, commands, how to
test), working (the working doc of one ticket: context, steps, files likely touched, how to
verify; link it with attach_working_doc), note (anything else). Working docs and every
other doc stay in Tares; they never go to Linear or GitHub. A rule or fact that holds for every
project goes in the shared docs with add_to_global instead. Returns the doc's id.
Inputs: body (required), kind (required), title (required), id, +1 more. Returns: result
write_milestoneA
Write one of the project's milestones, or change it when one with this name exists
(names are unique). Each milestone ships something a person can check: goal says what in
one line, checks are its acceptance checks, [{"check": "",
"expect": "", "for": "person"?}]. A check is the crew's (the default):
the crew runs it and records it when the milestone's last ticket merges. Mark for: "person"
only a step a person must do themselves (look at a screen, try a flow in the console); those
reach the person to accept.
position orders them (a new one goes last). To rename one, pass its current name or id as
id and the new name. Give tickets a milestone with write_ticket(milestone=). When
the project's tickets live in Linear or GitHub (link_tickets), a new milestone is created
there, one per call, and a repeat of the same name finds it again; goal goes to Linear or
GitHub as its description and checks stay here. Rename, reorder and delete a milestone in
Linear or GitHub (position is ignored there).
Inputs: name (required), id, goal, checks, +2 more. Returns: result
write_repo_mapA
Write the map of a GitHub repo (owner/name) that the builder and reviewer briefs serve:
layout, entry points, how to install, build, test and lint, conventions, the files tickets
touch most, known traps. One map per repo, shared by every project on it, at most 8,000
characters (about 2,000 tokens). body replaces the whole map, so start from the one in your
brief and pass its version as base (leave it empty when the repo has no map). If someone
wrote the map since, nothing is written and the answer is the map now: fold your change into it
and write again. note says what changed and becomes a dated line in its history. Write it when the
brief says the repo has none; update it when a merged PR changes the layout or the build, test
or lint commands.
Inputs: body (required), note (required), repo (required), base, +1 more. Returns: result
write_ticketA
Add a ticket to the project's list, or change one when id is given (its id or T).
When the project's tickets live in Linear or GitHub (link_tickets), a new ticket is created
there, one per call: write the milestones first, then the tickets in dependency order. A repeat
of the same title finds the issue again instead of making a second. depends_on is resolved
to the tickets already written; milestone must be one already written. Its status,
assignee and position come from Linear or GitHub, so naming them on a new ticket is
refused. An existing Linear or GitHub ticket can be retitled, moved to a milestone and, for
Linear, reordered here (position); its status, assignee and dependencies change there, and
attach_working_doc links its working doc. For a project whose tickets live in Tares: status
is todo, in_progress, done or canceled; position orders the list (a new ticket goes to the
end); milestone is the name of a milestone written with write_milestone ("" takes it out of
its milestone); depends_on lists the tickets (T or id) that must be done first ([] clears
them); assignee is the person it is for (a person id or an email; an email nobody on the cell
has is kept as written and the ticket shows as unowned; "" clears it), and assigning someone
to a ticket of a private project adds them to it; naming an assignee needs an enterprise
licence, without one leave it out. repo is the GitHub repo the ticket changes (owner/name),
for a project that spans several repos ("" clears it). Returns the ticket with its label
(T).
Inputs: title (required), id, repo, status, +5 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 83 tools
The 83 tools span many overlapping subdomains, and several concepts are easy to confuse: remember vs remember_for_project vs recall vs add_to_global, write_doc vs add_to_global, builder_brief vs review_brief vs get_ticket/pick_up, and desk_* vs assumptions. Individual descriptions often clarify the boundaries, but with this many tools an agent will frequently misselect or need to re-read several candidates before acting.
Most names are snake_case and readable, but there is no single convention: verb_noun names mix with question-style names like what_is_broken, how_is_project, my_work, and domain-prefixed names like desk_add. The use of create_/write_/add_/record_/set_ is not predictable enough for a strong naming score.
Eighty-three tools is far beyond a well-scoped set and makes the surface difficult to discover, remember, and use reliably. Even for a broad platform spanning projects, tickets, reviews, crews, incidents, sources, and memory, this is an extreme overload.
The surface is extensive, covering projects, docs, tickets, milestones, reviews, crew management, sources, triggers, incidents, grants, and secrets. However, lifecycle coverage is uneven: there are no obvious delete/update tools for sources, no trigger deletion, and no delete operations for docs, tickets, or milestones, leaving notable gaps in otherwise broad CRUD coverage.
Maintenance
Related MCP Connectors
Your own AI agent on an always-on cloud computer: Claude Code, Codex and more, or managed OpenClaw.
Autonomous and governed SRE & MLOps control plane for AI agent platforms.
People and AI agents build software together in persistent cloud sessions for Claude Code.
Your AI mind directs coding agents; work reviewed against your memories: Claude Code, Codex, Cursor
Related MCP Servers
- AlicenseAqualityAmaintenanceThe infrastructure for AI teams: a self-hosted server that gives a fleet of agents shared semantic memory, tasks, direct messages, and session handoff. Any agent that speaks HTTP participates: Claude Code, AutoGen, raw API scripts, anything.479MIT
- AlicenseAqualityDmaintenanceMaintenance, recovery, and observability for Claude Code. CLI + MCP server + dashboard.4069 npm109MIT
- AlicenseBqualityBmaintenanceTurns Claude Code into a self-driving AI company with autonomous CEO, agent teams, and self-improvement capabilities.126378MIT
- AlicenseNot gradedqualityFmaintenanceAn autonomous software-engineering pipeline for Claude Code that runs on real evidence: codebase intelligence tools, git analytics, deterministic verification rules, and zero LLM-judges-LLM. Every claim traces to a paper and every PR passes its own gates.1MIT