Skip to main content
Jig’s unit is a project’s engineering lifecycle — from project knowledge and sizing the work, through implementation and evidence, to deciding what the project should remember and cleaning up after. It is not a specification format, a prompt collection or a cast of agent roles.

Six choices that shape it

  1. Judgement and mechanics are separate. The agent analyzes, designs, reviews and decides what to remember, guided by skills. Shell scripts keep state, pick the relevant knowledge, run checks, install and clean up — without calling an AI model, so they are testable and cost nothing to run.
  2. Process follows risk. Trivial and local work finishes without ceremony; architectural and critical work needs an approved design and a stronger review. A change that is small to type but dangerous to undo still takes the heavier route.
  3. Knowledge has authority and a lifecycle. Durable knowledge is selected by path, domain, topic and stage. What an agent inferred stays proposed, and reaches no other agent until a human accepts it.
  4. Task notes are temporary. Plans and investigation notes stay in a local, ignored workspace. Only what should outlive the task becomes knowledge; the workspace is cleaned up after the merge.
  5. The process is installed like code. Skills, scripts and profiles are committed with the project. Upgrades replace what the framework owns and keep what the project changed.
  6. How far the agent may go is one person’s setting. Whether a finished task is left in the working tree or arrives as a merged pull request, and whether it may run a whole task without stopping to ask, lives in a gitignored file and is enforced by a script — never by the shared project configuration, so no one grants that trust on a colleague’s behalf.

Next to similar tools

These overlap with Jig but center on different things. The comparison reflects their public documentation as of 2026-09-10; it is not a feature checklist.

When Jig fits

Jig fits a team that wants the same process committed with the repository, cheap handling of routine changes, explicit human gates where mistakes are costly, knowledge that is accepted rather than assumed, and mechanics that can be tested without an AI model. It also fits someone building alone through an agent who cannot answer an engineering question and would rather have the change deployed: the same routes and the same review run unattended, the agent records every choice it made in your place, and your CI — not the agent’s confidence — decides whether it merges. What it does not do is remove the need for CI; a project with no checks is never merged into by an agent. Its scope is deliberately narrow, and so is its reach: it supports two runtimes, Claude Code and Codex, and its measurement stops where telemetry would begin — it can tell how much process a change asked for, never what the agent’s work cost.