command-tempo
One decision layer for everyone running several AI agents (Claude Code, Codex) on one project. Source-available under FSL-1.1-ALv2.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Badge for your README
Markdown
[](/listings/commandtempo--command-tempo)HTML
<a href="/listings/commandtempo--command-tempo"><img src="/api/listings/commandtempo--command-tempo/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
The kit is free and public. Clone it, then:
git clone https://github.com/commandtempo/command-tempo.git ~/src/command-tempo python3 ~/src/command-tempo/init.py ~/projects/my-agency --codex
Into an empty folder this makes a git repository, installs the kit, registers the MCP server for Claude Code (`.mcp.json`) and Codex (`.codex/config.toml`), and runs the decisions check. Then open Claude Code or Codex in the folder and say "run the Command Tempo setup interview".
`--desk --schedules` adds the desk and its connector guides, and the scheduled tasks rendered into `desk/schedules/` (loading nothing). These run on your machine and need no Command Tempo key. The ones that call an agent sign it in with an API key, not a personal Claude.ai or ChatGPT login (`templates/schedules/README.md`). The hosted relay for Slack and email comes with the Command Tempo platform, when it launches: you get its URL and token when you sign up.
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
README.md · README · 320 lines
- # Command Tempo
- Command Tempo is one decision layer for everyone running several AI agents (Claude Code, Codex) on one project.
- - Agents bring numbered decisions with concrete options: A, B, C, one marked recommended.
- - You answer wherever you are: in a session, in Slack, by email, on a GitHub issue. `2 A` is a full answer.
- - Your answer is recorded word for word, with date and source, before anything acts on it.
- - A recorded answer outranks every other instruction. Only the `MODE` kill switch (`halt`, `shadow`, `run`) outranks it.
- - Agents read a short digest, `rules-in-force.md`, at startup. The full record, `decisions.md`, is searched, never read in full.
- - Decisions agents take on their own go in `decision-log.md`, with their reasoning.
- ## Want it hosted? Join the waitlist
- The kit on this page is free, with its own desk module and team roles. The Command Tempo platform adds the hosted parts, in two plans, Desk and Team:
- - A relay for Slack and email answers, with nothing for you to host.
- - One sign-in for your tools.
- - A web viewer for the whole team.
- Desk and Team are coming soon. [Join the waitlist](https://www.commandtempo.com/?utm_source=github&utm_medium=repo&utm_campaign=kit) and you hear first.
- The core is plain files, a Python script and an MCP server, standard library only. Meaning search (embeddings) is optional. Transcript extraction and a curator are an optional module, installed separately.
- | Offer | Price | What you get |
- |---|---|---|
- | The primer | Free | A short PDF on running your agents from one conversation. No code. |
- | The guide | A$49 one-off | The whole method step by step, with templates, done with plain files. |
- | The kit | Free | This repository: everything above, the setup interview, the desk module (`--desk`), team roles (`people.json`), schedule templates and answers through GitHub issues or your own Slack and email connectors. Source-available under FSL-1.1-ALv2. |
- | The Command Tempo platform | Coming soon, monthly | Your decisions, context, run book and connections in one place: the relay for Slack and email answers with nothing to host, one sign-in for your tools, and the team web viewer. |
- | Full service | A$1,490 once | Full Throttle CEO installs the kit, connects your tools and records your first decisions with you. |
- Your agents run in Claude Code or Codex, signed in with your own account. Command Tempo never runs a model for you, and never asks for, stores or passes on your Claude.ai or ChatGPT login. Scheduled runs sign in with an API key or a business plan (see Scheduled tasks below).
- ## Install in one command
- The kit is free and public. Clone it, then:
- ```bash
- git clone https://github.com/commandtempo/command-tempo.git ~/src/command-tempo
- python3 ~/src/command-tempo/init.py ~/projects/my-agency --codex
- ```
- Into an empty folder this makes a git repository, installs the kit, registers the MCP server for Claude Code (`.mcp.json`) and Codex (`.codex/config.toml`), and runs the decisions check. Then open Claude Code or Codex in the folder and say "run the Command Tempo setup interview".
- `--desk --schedules` adds the desk and its connector guides, and the scheduled tasks rendered into `desk/schedules/` (loading nothing). These run on your machine and need no Command Tempo key. The ones that call an agent sign it in with an API key, not a personal Claude.ai or ChatGPT login (`templates/schedules/README.md`). The hosted relay for Slack and email comes with the Command Tempo platform, when it launches: you get its URL and token when you sign up.
- ## Setup interview
- `decisions.py setup` opens ten numbered questions that seed your first decisions: pushing to main, spend, outside messages, deletes, Slack, your tools, MODE, where decisions reach you, dependencies, and who else decides. You answer them like any decision, several at once (`1 B, 2 A, 3 A`). Question 6 takes several letters: `6 A B D`. Some answers also change settings: question 7 writes `MODE`, question 6 lists the connectors to set up. Every recommended answer works today, with or without the desk. Question 8 picks GitHub issues (`relay_github.py`, recommended), your own Slack connector, or sessions only. Question 5 says whether agents message you on Slack through your own connector. With `--desk`, question 8 also offers Slack or email through the hosted relay, and question 5 offers the end-of-day digest: both are labelled "with the Command Tempo platform, coming soon", and both work once you have a relay URL and token. The last step after the ten questions is the run book and roles (below). The questions live in `tools/decisions/setup-questions.json`.
- ## Run book and roles
- `run-book.md` says how work runs in your project: goals, definition of done, where work lives, how work flows, who runs what, commands, context, check-ins, and what no agent touches. `roles/` has four role files: the lead (the session you talk to), builder, reviewer and researcher. Both start as templates with `<placeholders>`. After the setup interview, the agent drafts `run-book.md` from the repo and asks you numbered questions for the rest; you write Goals. With the desk, every dispatch brief points the agent at both.
- ## The desk (`--desk`)
- Say "/desk" or "what needs me". The agent reads your sources through the connectors it already has (GitHub, Linear, Granola, Slack, email, Composio; guides in `.claude/skills/desk/connectors/`), then shows one screen:
- ```
- NEEDS YOU (2)
- 1. Ship the shorter pricing page copy? · github acme/site#212
- A: Ship the short version (recommended) · B: Keep the current copy
- 2. Review requested: Retry webhooks with backoff · github acme/api#88
- A: Dispatch a review agent, you approve its verdict (recommended) · B: Review it yourself · C: Dismiss
- IN FLIGHT
- - github acme/api#90 Webhook retries · codex · returned, in review · decision 3 A
- LANDED (since last desk)
- None.
- SOURCES
- GitHub ok · Linear ok · Slack: last read 27 Oct
- ```
- Every item has a number, so `2 A` answers item 2 whatever it is. The desk shows one item at a time, records your answer first, posts your decision on the work item it unblocks (`ask --unblocks github:acme/api#90`), dispatches an agent onto it, and checks the return with an independent review before it counts as done. Procedure: `.claude/skills/desk/SKILL.md`. Tool: `tools/desk/desk.py`.
- Scheduled tasks (`templates/schedules/README.md`): a morning gather so the screen is ready, and a health check every 6 hours, always. An end-of-day digest when setup question 5 is C (sent through the relay, with the Command Tempo platform), a nightly knowledge read with Haiku when the knowledge module is installed, and a relay sync every 5 minutes once the relay settings file exists. `init` names the reason for each one it skips. The gather and the knowledge read call an agent with no one watching, so they run on an API key (`ANTHROPIC_API_KEY`, or Claude Code's `apiKeyHelper` setting) or a Claude Team or Enterprise account, never a personal plan's login. After changing any of these, run the `init.py ... --desk --schedules` line again.
- ## Team
- `people.json` says who decides what:
- ```json
- {"owner": "alex",
- "people": {"alex": {"slack": "U0123", "email": "alex@agency.example"}, "jo": {"slack": "U0456"}},
- "areas": {"design": ["jo"], "spend": {"over": 500, "currency": "AUD", "people": ["alex"]}},
- "viewers": {"pm@acme.example": ["client-signoff:acme"]}}
- ```
- `ask --area design` sends a decision to jo. Only jo or the owner can answer it; anyone else's answer is refused and recorded nowhere. Each recorded decision names who made it (`Decided by:`). Changing `people.json` is itself a decision (`ask --people`), and `check` fails until the current file has a recorded decision. Viewers sign in to the relay's web viewer with an emailed link and see only their areas.
- ## Install (details)
- Needs Python 3.9 or later, on macOS or Linux (Windows: WSL), and a clone of this repository.
- ```
- git clone https://github.com/commandtempo/command-tempo.git ~/src/command-tempo
- python3 ~/src/command-tempo/init.py /path/to/your/project
- ```
- `init` adds the files below to the project, registers the MCP server for Claude Code in `.mcp.json`, adds a Claude Code SessionEnd hook that runs `decisions.py end-session`, adds a git pre-commit hook that runs the decisions check, and runs the check once. It never overwrites `MODE`, `decisions.md`, `rules-in-force.md`, `decision-log.md`, `run-book.md` or the files in `roles/`. An existing `CLAUDE.md` or `AGENTS.md` gets the decision-layer section appended once. Run it again to upgrade the tools.
- ### Claude Code
- Nothing more. Start Claude Code in the project. Claude Code reads `CLAUDE.md`, loads the `decision` skill from `.claude/skills/decision/`, and asks to enable the `decisions` MCP server from `.mcp.json`.
- ### Codex
- Codex reads `AGENTS.md`, which `init` makes a link to `CLAUDE.md`. Register the MCP server in `~/.codex/config.toml` (`init` prints this block with your project's path), or run `init --codex` to write it to the project's `.codex/config.toml`:
- ```toml
- [mcp_servers.decisions]
- command = "python3"
- args = ["/path/to/your/project/tools/decisions/mcp_server.py"]
- ```
- The decision procedure is at `.claude/skills/decision/SKILL.md`, linked from `.agents/skills/decision/`; `AGENTS.md` points Codex to it.
- Codex runs every shell command as a new process, with no session ID. The tools then use one session per project per day (`shell-2026-10-29`), so `1 A` answers decision 1 in any later command that day, from any terminal. The next day, the first command moves the day before's open decisions to board numbers and prints each move: `2 is now 418 outside this session: Event store database.` To number one agent or terminal on its own, set a session ID before running the tools:
- ```
- export DECISIONS_SESSION_ID=codex-api
- ```
- `--session <ID>` on a single command does the same. Claude Code sets its own session ID; nothing to do there.
- ### Meaning search (optional)
- Words search (SQLite FTS5) works with no packages. To also match on meaning:
- ```
- python3 -m pip install fastembed==0.9.0 sqlite-vec==0.1.9
- python3 tools/decisions/decisions.py model download # once, about 65 MB, into ~/.cache/decisions/fastembed
- python3 tools/decisions/decisions.py status # says "hybrid", or "words only" and why
- ```
- Use the same interpreter in `.mcp.json` (`init --python /path/to/python`). Queries never reach the network; the model loads from the cache only.
- ## The decision format
- An agent opens a decision with the tool:
- ```
- python3 tools/decisions/decisions.py ask --title "Event store database" \
- --question "Which database holds the event store?" \
- --option "Postgres on the existing server" --option "SQLite file next to the app" \
- --option "Managed DynamoDB" --recommend A --by claude-code
- ```
- and shows you:
- ```
- 2. Which database holds the event store?
- A: Postgres on the existing server (recommended) · B: SQLite file next to the app · C: Managed DynamoDB
- ```
- You reply `2 A, keep the schema portable`. Several at once: `2 A, 3 C`. The agent records your reply before doing anything else:
- ```
- python3 tools/decisions/decisions.py record --answer '2 A, keep the schema portable' --source 'session, claude-code'
- ```
- and tells you `Recorded 2: Event store database. Decision: Option A: Postgres on the existing server; keep the schema portable (stands until changed)`. Your decision goes into `decisions.md`, under the decision's record ID (the `Ruling:` line holds what you decided):
- ```
- ## <record ID>: Event store database
- - Date: 2026-10-29
- - Question: Which database holds the event store?
- - Options:
- - A (recommended): Postgres on the existing server
- - B: SQLite file next to the app
- - C: Managed DynamoDB
- - Answer (verbatim):
- > 2 A, keep the schema portable
- - Source: session, claude-code, recorded 2026-10-29T14:02:11+11:00
- - Ruling: Option A: Postgres on the existing server; keep the schema portable
- - Standing: yes
- - Decided by: owner
- - Asked by: claude-code
- ```
- and, when it stands until changed, into `rules-in-force.md` under its group. A one-off decision (`ask --one-off`) has no line there:
- ```
- - Event store database: Postgres on the existing server; keep the schema portable (<record ID>)
- ```
- A later decision replaces an earlier one with `ask --supersedes <record ID>`; `record` then removes the old line.
- ### Numbers
- Every ask and decision is stored under a record ID, a short hash that any number of agents can create at once without clashing. You never see a record ID. You see plain numbers, in one of two modes.
- Desk mode is a live session. The session shows its decisions as 1, 2, 3 in the order raised, and `2 A` in that session answers number 2. Each session keeps its own numbers in `asks/.desk/<session ID>.json`, so two sessions can both have a 1 without clashing. The session ID is `--session`, else `DECISIONS_SESSION_ID`, else Claude Code's own session ID, else one shell session per project per day (see Codex above).
- Board mode is anything that outlives the session: Slack, email, a tracker. A board decision shows the tracker's number: a GitHub issue number when the project has a GitHub remote and the `gh` CLI, otherwise the next free number, claimed by creating `asks/.numbers/<number>` only if no one has. That check runs on one machine: two machines can claim the same number before a pull, and git then reports a merge conflict on `asks/.numbers/<number>`. With agents on several machines, push the project to GitHub and install `gh`, so numbers come from GitHub issues. Board numbers never repeat. A desk decision still open when the session ends moves to a board number, and the agent tells you the number. It keeps its desk number when no decision has used that number before (`2 keeps its number outside this session: Event store database.`), otherwise it takes a new one (`2 is now 418 outside this session: Event store database.`). A GitHub issue number is always new. The move runs through `decisions.py end-session`, which a Claude Code SessionEnd hook also calls.
- Numbers carry on through a session: after the ten setup questions, the first decision you see is 11.
- One decision has one number in a session, the same in `open`, `show`, the desk screen and `record`. A decision already on the board shows its board number, and desk numbering skips the numbers board decisions hold. Whatever number `open` or the desk shows, `5 A` answers it.
- `check` fails if two decisions share a record ID.
- ### The decisions check
- ```
- python3 tools/decisions/decisions.py check
- ```
- Fails (exit 1) when a standing decision has no line in `rules-in-force.md`, a line has no decision ID or names a superseded, one-off or unknown decision, two decisions share an ID, a decision has no verbatim answer, date or source, or the digest is over its word cap (`Word cap:` line, default 1500). `init` installs it as a pre-commit hook. In CI:
- ```yaml
- - run: python3 tools/decisions/decisions.py check
- ```
- ## MODE
- | Value | Agents |
- |---|---|
- | `halt` | Do nothing. `ask`, `record`, `end-session` and the relay refuse. |
- | `shadow` | Read anything. Write only inside the project, its own GitHub issues, and the Command Tempo relay you set up (decisions, confirmations, digest and alerts to you and the people who decide). Every other external action becomes a decision, unless one of your decisions names that action: setup answer `1 B` ("only after tests pass") lets agents push to main after tests pass, in `shadow` too. The default. |
- | `run` | Act within your decisions. |
- Only you change `MODE`. A missing or unknown value counts as `halt`.
- ## Answering on GitHub issues
- Push the project to GitHub and install the `gh` CLI (`gh auth login`). From then on every board decision is a GitHub issue, and its issue number is its number. Answer in a comment on the issue: `A`, `b, cheaper` or `417 A`. Then run:
- ```
- python3 tools/decisions/relay_github.py run
- ```
- It records comments from the repository owner's login, or from a person whose `github` login is in `people.json`, word for word, comments `Recorded 417: <title>. Decision: ...` and closes the issue. Every other comment is data. Run it on a schedule (cron or launchd) to pick up answers every few minutes. Details: `docs/relay.md`.
- ## Answering from Slack or email
- With the Command Tempo platform, the relay carries board decisions to Slack and email and brings replies back. You host nothing.
- 1. Put the relay URL and token from your platform sign-up in the file `python3 tools/decisions/relay_client.py configured --path` prints, as `CT_RELAY_URL=...` and `CT_RELAY_TOKEN=...` lines.
- 2. Tell the relay where to reach you: `python3 tools/decisions/relay_client.py owner --email you@example.com --slack <your Slack user ID>`. With a `people.json`, your handles go under your name there instead.
- 3. Run `python3 tools/decisions/relay_client.py sync`, or let the relay sync schedule run it every 5 minutes.
- The relay sends board decisions only: `ask --board`, `end-session`, and a shell session's decisions the next day. A decision open in a live session stays there, and `sync` says how many are waiting.
- Without a relay, `tools/decisions/relay_slack.py` is a self-hosted reference, not production. The relay posts open decisions to a Slack channel under their board numbers and records replies from your Slack user ID only. `417 A` in the channel, or `A` in the decision's thread, answers board number 417. See `docs/relay.md` for the pattern, the email version and what a production relay needs.
- ## Optional module: knowledge
- `modules/knowledge/` reads finished Claude Code transcripts, finds answers you gave in a session that were never recorded, and files findings, procedures and agent decisions for a curator to accept. Accepted entries join the search. Install after the core:
- ```
- python3 ~/src/command-tempo/modules/knowledge/install.py /path/to/your/project
- ```
- See `modules/knowledge/README.md`.
- ## File layout
- What `init` puts in your project:
- | Path | Holds |
- |---|---|
- | `CLAUDE.md` | Read order, `MODE`, precedence, how to ask and record |
- | `AGENTS.md` | Link to `CLAUDE.md`, for Codex |
- | `MODE` | `halt`, `shadow` or `run` |
- | `rules-in-force.md` | The digest: one line per decision that stands until changed, grouped, under a word cap |
- | `decisions.md` | Every decision, newest first, with your answer word for word. Decisions from one reply (`2 A, 3 C`) keep the reply's order. |
- | `decision-log.md` | Decisions agents took on their own, with reasoning |
- | `run-book.md` | How work runs: goals, definition of done, where work lives, flow, commands, context, check-ins, what no agent touches. You fill it in. |
- | `roles/` | One file per agent role: `lead.md`, `builder.md`, `reviewer.md`, `researcher.md` |
- | `asks/<record ID>.md` | Open decisions, one file each, removed when answered |
- | `asks/.desk/<session ID>.json` | Desk numbers for one session (1, 2, 3 to record ID). Gitignored. |
- | `asks/.numbers/<number>` | Board numbers: each file holds the record ID that claimed the number. Committed. |
- | `.claude/skills/decision/SKILL.md` | The decision procedure (Claude Code skill; Codex reads the same file) |
- | `.mcp.json` | Registers the `decisions` MCP server |
- | `.claude/settings.json` | SessionEnd hook: `decisions.py end-session` |
- | `tools/decisions/decisions.py` | `ask`, `record`, `log`, `open`, `show`, `end-session`, `check`, `search`, `status` |
- | `tools/decisions/mcp_server.py` | MCP server: `decisions_search`, `decisions_get`, `decisions_open`, `decisions_status` |
- | `tools/decisions/search.py` | FTS5 words search, plus embeddings when installed |
- | `tools/decisions/relay_github.py` | Answers on GitHub issues: posts board decisions, records the owner's comments |
- | `tools/decisions/relay_slack.py` | Reference Slack relay (self-hosted) |
- | `tools/decisions/relay_client.py` | Client for the hosted relay: push decisions, pull and record replies |
- | `tools/decisions/setup-questions.json` | The setup interview |
- | `people.json` | Team: who decides what, viewers. Created by team setup. |
- | `.claude/skills/desk/` | Desk: the desk skill and connector guides (`--desk`) |
- | `tools/desk/desk.py`, `tools/desk/scheduled.py` | Desk: the screen, dispatch, returns, health, digest; the scheduled-task runner |
- | `templates/schedules/` | Desk: launchd template, routine prompts, install steps |
- | `meeting-decisions.md` | Desk: decisions from meetings, quoted word for word, searched with your other decisions |
- | `desk/` | Desk: `gather.json`, `screen.txt`, `runs.jsonl`, `answers.jsonl`, `schedules/`, `logs/` |
- | `tools/decisions/config.json` | Extra markdown files to search (`extra_sources`, globs) |
- | `tools/decisions/.state/` | Search index, locks, relay state. Gitignored. |
- This repository:
- | Path | Holds |
- |---|---|
- | `init.py` | The installer |
- | `template/` | What `init` copies |
- | `modules/knowledge/` | Optional extraction and curator module |
- | `modules/desk/` | The desk, installed with `init --desk` |
- | `docs/relay.md` | Slack and email relay pattern |
- | `tests/` | `python3 -m unittest discover -s tests` |
- | `LICENSE`, `LICENCES.md` | Licence (FSL-1.1-ALv2) and third-party inventory |
- ## Tests
- ```
- python3 -m unittest discover -s tests
- ```
- The hybrid search test runs when `DECISIONS_TEST_PYTHON` names an interpreter with fastembed and sqlite-vec, and `DECISIONS_MODEL_CACHE` holds the model.
- ## Licence
- Command Tempo is source-available under the Functional Source License, Version 1.1, ALv2 Future License (SPDX `FSL-1.1-ALv2`, in `LICENSE`). You can read, run, change and share the code for any purpose except offering a competing product or service. Each version becomes available under the Apache License 2.0 two years after it is released.
- FSL is a Fair Source licence. The full setup service uses the same code under the same licence; the setup agreement covers the service, not the code. Third-party packages keep their own licences (`LICENCES.md`).
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.