Radar

When an agent says “done”, see what was checked and what still needs checking.

Radar is the integration layer for parallel coding agents:

• Combine: check their combined committed tree before merging.
• Land: inspect branch pairs, stacks, landing order and conflict repair briefs.
• Prove: retain what was checked in local records, commit trailers and opt-in PR checks.

Radar checks committed agent branches together before you merge. Two green branches can still break when combined. It builds their combination privately, checks it without running repository code, and explains missing evidence. Tests run only when you request them. No API key, telemetry, or changes to your branches.

radar gate

The result shows checks that passed, conflicts with source locations, and checks that could not finish. radar gate --run adds related tests when you authorize execution. Install, then try the one-minute example below.

Full demo transcript. This is a fixture demonstration. Real-history replay is available; human-labeled recall is not yet available. See benchmark methods for measurement scope and limitations.

Try it in one minute

Two agents edit separate branches. Each branch passes its tests. Combined, they fail. Paste this into a shell after installing Radar (it needs Git and Python 3 and works in a new temporary directory):

cd "$(mktemp -d)" && git init -q -b main shop && cd shop
git config user.name demo && git config user.email demo@example.com
printf 'def price():\n    return 1\n' > backend.py
printf 'export const QUANTITY = 1;\n' > frontend.ts
cat > test_checkout.py <<'PY'
import re, unittest
from pathlib import Path
from backend import price

class Checkout(unittest.TestCase):
    def test_budget(self):
        quantity = int(re.search(r"QUANTITY = (\d+)", Path("frontend.ts").read_text())[1])
        self.assertLessEqual(price() * quantity, 2)
PY
git add . && git commit -qm baseline
git worktree add -q -b agent-backend ../backend
git worktree add -q -b agent-frontend ../frontend
printf 'def price():\n    return 2\n' > ../backend/backend.py
git -C ../backend commit -qam 'Raise price'
printf 'export const QUANTITY = 2;\n' > ../frontend/frontend.ts
git -C ../frontend commit -qam 'Raise quantity'

radar gate          # PASS (static): the branches merge cleanly; no test ran
radar gate --run    # FAIL: the combined tree breaks the budget test

The same report as plain text

$ radar gate --run
Radar gate: FAIL — 1 of 1 test command failed on the combined tree
2 branches onto main @ e4d5f9ed44f0

  agent-backend   2b02738cceb2  1 file changed
  agent-frontend  93f3399937e6  1 file changed

  ✓ Merge           branches merge without conflicts
  · Contracts       none declared, so no contract was checked (radar discover proposes candidates)
  ✗ Tests           1 of 1 test command failed on the combined tree
  ? Test selection  incomplete — 1 changed file has no related test
  policy supported-integration requires textual_merge, no_breaking_contracts, integration_execution, test_selection

Problems
  ✗ integration_execution_failed
    Combined verification command python3 -m unittest discover -s . -p test_checkout.py (in .) returned failed (exit 1).
    failed cases: test_checkout.Checkout.test_budget
    look at (import-based lead): agent-backend (backend.py)
    reproduce: d=$(mktemp -d) && git worktree add --detach "$d" e4d5f9ed44f0 && cd "$d" && git merge --no-ff --no-edit --no-verify 2b02738cceb2 && git merge --no-ff --no-edit --no-verify 93f3399937e6 && python3 -m unittest discover -s . -p test_checkout.py
    fix: Reproduce the supplied command on the combined changes, reconcile producer/consumer assumptions, and repair the failing invariant.

Tests (balanced): ran 1 of 1 selected command
  ✗ python3 -m unittest discover -s . -p test_checkout.py  (in .; 1 recognized test)
  Test files: 1 inventoried, 1 selected (relationships are not behavioral coverage)
  ? Uncovered changes (no established test relationship): frontend.ts
    Resolve with supported tests, review --suite full, or explicitly select a limited --policy.

Next: repair on the branches above, commit, then rerun: radar gate --run
Details: add --json. Radar never touches your branches; the combination is built in private Git state.

look at is an import-based repair lead, not proof of blame. Failed commands are automatically checked once on base within the shared command/time budget. Failures already present there leave verification NOT VERIFIED and have no branch lead; additional candidate failures still FAIL. If the base check cannot run or compare identities, the candidate failure remains FAIL. Optional subset diagnostic reruns are off by default. Use radar gate --run --attribution-runs 8 to look for a smaller branch combination that reproduces the failure; observed lines describe those bounded reruns and remain repair leads. The reproduce line rebuilds the same commits in a throwaway worktree under a new temporary directory (remove it later with git worktree remove). It skips commit hooks like Radar does, but checkout and merge hooks, your Git configuration and your environment still apply, so it can differ from Radar's sanitized run.

Install

Linux (amd64, arm64) and macOS (Apple Silicon, Intel):

curl -fsSL https://raw.githubusercontent.com/Jake-Network/radar/v0.2.0/scripts/install-release.sh | bash -s -- --version v0.2.0

This installs a checksum-verified binary to ~/.local/bin (--dir changes it). Binaries need no Go or C compiler; Git is required, and radar gate --run uses your repository's own test runners. Then:

radar doctor

Windows binaries are not published yet. This checkout disables private Git line-ending conversion and adds native qualification jobs; those jobs still need successful hosted runs. Build from source with Go 1.23+ and a native C compiler (for Tree-sitter):

git clone --branch v0.2.0 --depth 1 https://github.com/Jake-Network/radar.git
cd radar
go build -trimpath -o radar ./cmd/radar

Use the GitHub binary installer or tag checkout for 0.2.0. The version's earlier source commit was cached by the Go module proxy before the hook release; go install ...@v0.2.0 can therefore install that earlier implementation.

To install the current development checkout, use go install ./cmd/radar from its root. Landing, cross-worktree drift, trailer/show and SCIP described here are development additions, not features retroactively added to the v0.2.0 binaries. Local Claude Code/Codex marketplace packages can install the hook and skill after Radar is on PATH. These local catalogs have not been submitted to an external marketplace. Release packaging generates a Homebrew formula; a published tap still requires a qualified release.

Release details and runtime limits: RELEASING.

The 0.2.0 release adds continuous saved-change previews and installable native coding-agent Stop hooks. See the changelog for the release scope.

First run in your repository

radar doctor          # base, agent branches, uncommitted worktrees, test runners, next step
radar setup claude    # optional: connect Claude Code (or codex, both); add --dry-run first
radar gate            # combine every agent branch and check it; runs no code
radar land            # pair matrix, ancestry chains and an estimated landing order
radar gate --run      # also run the related tests on the combined tree

Radar needs no configuration. radar gate picks the base (origin/HEAD's branch, main, master or trunk) and every worktree branch with commits beyond it. Name branches to choose them: radar gate agent-a agent-b --base develop. Gate checks committed changes; uncommitted work in a worktree is listed and left out, so commit first. radar watch --include-dirty can instead preview saved staged, unstaged and nonignored untracked changes in private snapshots; those results do not verify the committed branches.

In a terminal, bare radar opens a menu that shows the same information and runs the same commands (tests only after you confirm). radar watch rechecks while agents commit; see watch. radar gate --overlap inspects saved cross-worktree drift. Use radar land --apply to publish only a private integration ref, and radar gate --trailer to record a passing selected policy. Pair compatibility and saved snapshots do not replace verification of the final committed combination.

Reading the result

Verdict	Exit	Meaning
PASS (static)	0	Required supported static checks passed. Undeclared or unsupported checks establish no evidence. No test ran
PASS (selected policy; bounded verification)	0	The selected tests also ran and passed on the combined tree. Not full coverage
FAIL	1	A supported static conflict, a breaking declared contract, or a failing test on the combined tree
NOT VERIFIED	1	Required evidence is missing. Each gap has a fix: line
ERROR	2	A check errored or timed out. If Radar cannot start (bad ref, unsupported layout), it prints radar: … and Next: instead, also exit 2

Marks: ✓ passed, ✗ failed, ? not verified, ! needs attention, · not checked or skipped. Color only decorates them; NO_COLOR and pipes give plain text. --json output is never styled. Every report ends with one Next: step.

Common NOT VERIFIED causes and fixes:

• A test runner could not start. Radar copies only committed files, so node_modules and virtualenvs are missing from its private copy, and it never installs dependencies. Install the runner, or run those tests yourself.
• The command budget ran out. Raise it with --max-commands N.
• Only documentation changed. No test applies to documentation by static relationships, and Radar cannot show that no test reads it, so --run has no evidence. The static radar gate result is what Radar verifies here.
• A changed file has no related test. Static imports found none. Add a test, try --suite full, or choose a limited --policy deliberately.
• Test discovery skipped a test or configuration file (oversized, symlink, unreadable), so the inventory is incomplete. A large non-test source omission is reported separately and does not block inventory.

Radar refuses symlinks and submodules in the combined tree. If a shallow clone lacks the required history, fetch it explicitly with git fetch --unshallow (or use fetch-depth: 0 in Actions); Radar does not fetch.

Agents

radar setup claude (or codex, or both) installs a native Stop hook, a project skill and the MCP server. The hook checks saved changes before each response ends and returns supported static failures to the agent for one repair continuation. It needs no structured plan and runs no repository code. It previews the current branch first, then checks peers selected by file and supported dependency relationships within the remaining budget. Unchecked peers remain NOT VERIFIED. Select an explicit combination when installing:

radar setup both --base main --branches agent-api,agent-client

Restart the agent after setup. In Codex, review and trust the installed definition with /hooks; installation alone does not activate untrusted hooks. Use --hook=false to install only the skill and MCP configuration. Portable native plugin packages and their installation commands are documented in agent installation.

Agents can also call radar_gate (or radar gate --json) before they propose a merge, read gate.verdict and next, repair, commit and recheck. Agents never run --run on their own: it executes repository code, so a person authorizes it. radar help agents prints the agent contract, and AGENT_GUIDE walks through the whole workflow.

Advanced: what a PASS means

Radar reports evidence. It doesn't certify correctness.

• PASS means every named requirement passed within the reported scope. It is not comprehensive verification. PASS (static) means no test ran.
• Import-based analysis follows imports. It does not resolve compiler types or see runtime reads such as files, environment variables or network calls.
• Attribution (observed, look at) is a lead for repair. Each rerun happens once, so a flaky test can mislead it.
• Not a sandbox: --run executes your tests with your permissions in a private copy of the combined source. That copy is not an operating-system sandbox.

Documentation

Need	Guide
Commands, watch, plans and demos	Usage
Claude Code / Codex hooks and plugins	Agents
Verdicts, policies, test selection and evidence	Verification
Supported analysis and future work	Capabilities
Multiple repositories and declared links	Workspaces
Execution, data and trust boundaries	Security
Packages and design decisions	Architecture
Measured results and their limits	Benchmarks
Native packaging and publication	Releasing

For CI, use the GitHub Actions integration with explicit branches and required checks.

Development

go test ./...
go vet ./...
bash scripts/smoke.sh "$(go build -o /tmp/radar ./cmd/radar && echo /tmp/radar)"
make demo-all

Native release jobs target Linux and macOS (amd64 and arm64). Tags prepare assets; publishing requires a separate manual request. See RELEASING and the changelog. See contributing for development conventions. MIT licensed.