How CRUX works: your tracker, a workflow, and agents a person starts

A task in the tracker's Implementation status; the workflow gives that status the developer role, a chat agent and three pipeline steps; Needs you shows a checkpoint to approve and the next step waiting for a click on start.

CRUX team · · Updated · 6 min read

The problem: a tracker and agents with no shared rules

Most teams that build with AI already have two things. A tracker (Jira Cloud, Linear, Plane or GitHub Issues) where the work is planned, and coding agents (Claude Code, Codex, Cursor) that do more and more of it. What they usually lack is anything that connects the two.

So every agent session is improvised. Someone copies a task into a prompt, decides from memory which rules the agent should follow, and checks the result in whatever way they remember that day. The next person does it differently. The tracker says the task is In progress, but nobody can see which agent is working on it, what it was told, or who approved what it produced.

CRUX is the layer between the two: one set of rules, per project, that says what happens to a task in each status, who is responsible, and which agents help.

The tracker stays the source of truth

CRUX doesn't replace your tracker or copy your board into a new one. Tasks, statuses, comments and sprints stay where your team already works. CRUX reads them, and agents write back to the same tasks: a question, a plan, a summary of a change. It doesn't ask you to change how your tracker is set up: it adapts to your statuses and task types as they are.

That matters for two reasons. People keep working in the tool they know, and everything an agent did is on the task, under the name of the person who started it, for anyone on the team to read later.

The workflow: status → role → agents

A workflow is the project's rules, kept as plain files (a .crux/ folder, in your repository when the project has one). For each tracker status CRUX acts on, it says three things:

  1. The role that owns it. A role is a hat a person wears: developer, QA, project manager, designer. A person picks the roles they work as, and the dashboard shows them those statuses and agents.
  2. The agents that help there, each with its own instructions and skills (written methods it follows, such as how to run a technical interview or how to review a pull request).
  3. What each step leaves behind: an artifact, a structured comment on the task that the next step reads instead of someone else's chat history.

For example, the Implementation status belongs to the developer role, and its steps are a developer agent that writes the code and opens a pull request, a reviewer that checks it against the project's rules, and a wiki curator that updates the project docs. We describe this in more detail in Stop writing prompts: why AI coding agents need a workflow.

The role flows on a workflow's Overview, one card per status. IMPLEMENTATION belongs to the Developer role, with one chat agent and a three-step pipeline: developer, reviewer, wiki_curator. DEVELOPER_INTERVIEW and READY_FOR_IMPLEMENTATION also belong to Developer, QA_PLANING to QA. Each card names its board column.
The Workflow overviewEach status CRUX acts on, with the role that owns it, its chat agents and its numbered pipeline.

Two kinds of agents, and both wait for a person

Agents in a status come in two kinds:

  • Chat agents are helpers you talk to: they interview the person who knows the answer, draft test cases, or suggest what to pick up next. (More in AI agents for the rest of the team.)
  • Pipeline agents are the ordered steps of a status, like developer → reviewer → wiki curator above. Each one posts its artifact to the task.

Neither kind starts by itself. No agent in CRUX runs in the background: a chat begins when someone opens it, and a pipeline step begins when a person starts it. When one step finishes, the next one waits for you. You can start a step from the dashboard, or from Claude Code with the crux plugin (/crux:crux-run).

Each agent also runs in one of two places:

  • Runs on CRUX: on CRUX's servers, with the model and key the project set up. It reads the tracker, and the code and wiki when the project allows, but changes no code.
  • Runs on your machine: in your own coding agent, in your checkout, on the plan you already pay for. This is where code gets written.
The two cards of a new chat with a chat agent: Run on CRUX, with Start session and the note Runs on CRUX · this project's Anthropic key, and Run on my machine, with Copy prompt and the note Runs on your machine · your coding agent's own model.
Where it runsBefore anything starts, each card says where the chat would run: Start session on CRUX, or copy the prompt into your own coding agent.

Approval checkpoints and Needs you

Starting every step is one click, but people don't watch every step. They check in at a few approval checkpoints, the points where a wrong turn is still cheap to fix: when the agent has understood the task, when it has a plan, and when it shows the result. At each one the agent drafts its artifact in the chat, you correct it, and it posts only after an explicit "ok". Between checkpoints the work goes on without you.

When an agent waits for your approval, or a session fails, it shows up in Needs you on your home page, next to any requests that wait for you. So you don't have to keep every running session in your head: what needs you comes to you.

Agents don't move tasks between statuses. A person does, in the tracker or by asking an agent to do it for them. (Why we keep it this way: Not an autonomous AI developer.)

Five steps to your first pipeline run

Getting from sign-up to a first run takes five steps:

  1. Organization. Your team, its projects and its agents live in one. You can invite people later.
  2. Project. One project in your tracker linked to CRUX: a Jira project, a Linear team, a Plane project, or the issues of a GitHub repository, with statuses from a GitHub Projects board or S: labels. An admin of your CRUX organization connects the tracker once. Jira Cloud and Linear connect by OAuth, and your workspace admin may have to approve the app. GitHub Issues connects through a GitHub App on your GitHub organization. Plane takes a personal token you paste in. Agents that run on CRUX also need a model key for the project.
  3. Workflow. Pick a template, or let your coding agent interview you about the team and propose one as a pull request. You adjust the details in the dashboard.
  4. Connect your coding agent. CRUX speaks MCP, the standard way coding agents use outside tools. You add CRUX to Claude Code, Codex, Cursor or another MCP client with a personal token; your agent then reads the project's tasks and workflow and acts as you. It takes about a minute, once per project.
  5. First pipeline run. Pick a task, start its first step, answer the agent's questions, and approve its artifact at the first checkpoint.
The five-step path on the CRUX home page. Create your organization, Create your first project and Set up the workflow are done, each saying what was done for Acme and its Storefront project. Connect your coding agent is the current step, with its button, and Start your first pipeline run waits until step 4 is done.
The path on your home pageA step that is done says what was done, the current one has its button, and the later ones wait their turn.

When you join a team that already has its organization, project and workflow, you start at step 4: connecting your own coding agent.

In short

  • Your tracker keeps the tasks; CRUX adds the rules for what happens to them.
  • A workflow gives each status an owner role and its agents, and every step leaves an artifact on the task.
  • Chat agents and pipeline agents start only when a person starts them, either on CRUX or on your machine.
  • People approve at checkpoints, and Needs you shows what is waiting for you.

Try this on your own project. CRUX is free for one person, no card.

Start free

Next: A CRUX workflow: statuses, roles and levels

See also: A Claude Code team workflow on Jira, Linear or GitHub

All articles