Skip to main content
Glama

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.

PyPI License: MIT Docs CI

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 over

Needs 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

Software Factory

the crew, planning, tickets, the console, teams and commands

AI SRE

connecting your data, watching, incidents, services and runbooks

Platform

the engine underneath: connectors, timelines, triggers, agents and projects

Deployment

Docker, servers, TLS and auth

AI resources

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 tools
add_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

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

    B3/5.0

    Scored across 83 tools

    Disambiguation2/5

    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.

    Naming Consistency3/5

    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.

    Tool Count1/5

    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.

    Completeness3/5

    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

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      A
      maintenance
      The 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.
      47
      9
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      An 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.
      1
      MIT