For Coding Agents

You want an agent — Claude Code, Codex, Cursor, or a CI bot — to drive Jaunt without a plugin or a server to install. Codex and Claude Code also have first-party plugins that package the guard hook, freshness summary, and build/convert/doctor skills: see the Codex plugin and Claude Code plugin. Everything the agent needs is on the CLI: a primer to load into context, structured output on every command it drives, and exit codes it can branch on.

The Primer: jaunt instructions

Load a project-aware briefing into the agent's context before it operates Jaunt:

jaunt instructions          # framework rules + a live snapshot of this project
jaunt instructions --json   # {command, ok, text, project} for tooling

The output covers the framework rules — the two authoring modes, the build/test loop, how to write a good spec, the command and exit-code reference — followed by a live snapshot of the current project: resolved [paths], engine and model, or version-2 target routes, semantic-gate and repo-map settings, and which Python or TypeScript modules are stale. It ships with the package, so the briefing always matches the installed version. The --json form is what you feed to a harness: text holds the primer, project holds the snapshot.

Run outside an initialized project it still succeeds (exit 0), printing the framework rules plus a note to run jaunt init. That makes it safe to load unconditionally at the start of an agent session.

For this documentation itself, fetch jaunt.ing/llms.txt — the full docs as one plain-text file, built for loading into an agent's context.

Machine-Readable Output

The commands agents drive — including sync, design, build, test, check, status, specs, instructions, jobs, log, tree, clean, and watch — accept --json (structured output on stdout, errors on stderr). A few interactive/hook commands (guard, daemon stop, skill show) do not:

jaunt specs --json      # spec list + dependency graph
jaunt status --json     # stale/fresh modules, contract drift, strength
jaunt build --json      # {"command": "build", "ok": true, "generated": [...], "refrozen": [...], ...}

Progress output is agent-aware too: --progress {auto,rich,plain,none}. auto is rich on a TTY and plain lines off-TTY, and an explicit --progress plain composes with --json (progress on stderr, JSON on stdout).

Reading The Docs As An Agent

The canonical machine-readable briefing is jaunt instructions, not this site: it ships with the installed package, works offline, and always matches the version the agent is running. Prefer it over scraping documentation pages — scraped docs can describe a different release than the one on the machine.

These guide and reference pages are authored as plain Markdown (MDX) under docs-site/content/docs/ in the repo, so an agent that does want the prose can read the source files directly from GitHub rather than parsing rendered HTML.

The Agent Loop

The intended workflow with the background daemon running:

git commit -m "spec: tighten normalize_email contract" \
  && jaunt jobs wait --timeout 1800

Exit codes are the protocol: 0 green, 4 a job failed or parked, 5 timeout. See the full table in the CLI reference.

Keeping Agents Out Of __generated__/

Generated code is overwritten on every build, so an agent must fix specs, not output. jaunt guard is a PreToolUse hook: it reads the tool-call payload on stdin and, when the target sits under __generated__/, returns a decision that points the agent back at the owning spec. The Codex plugin and Claude Code plugin ship this hook prewired, including protection for provenance-headed generated .pyi files. Or wire the Claude form yourself via .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|MultiEdit|Write|Read|NotebookEdit",
        "hooks": [{ "type": "command", "command": "jaunt guard" }]
      }
    ]
  }
}

For harnesses without hook support the barrier is advisory — jaunt instructions states the rule, and CI catches any drift with jaunt check.

The Principles Behind The Design

Jaunt's design follows a written coding-agent principles framework — six core laws plus named corollaries (value migrates to spec + verification; the model proposes, a deterministic and independent verdict disposes; treat everything the model reads as untrusted; …). The full document lives in the repo at docs/principles/2026-06-29-building-with-coding-agents.md, and the build prompt preamble embeds the laws so the generator operates under the same rules.

Next: Codex Plugin.