Delimit

</> Delimit

Keep the state. Change the model.

Delimit keeps your decisions, tasks, and handoffs on your machine, so the next AI coding session picks up where the last one stopped, even in a different assistant.

[npm] [GitHub Action] [License: MIT] [Glama Score]

Glama directory grades: License A · Quality A · Maintenance A. Observed September 15, 2026, for this public repository. View the listing.

The problem

• Your agent forgets what you decided last session, then asks again or quietly decides differently.
• It redoes work that was already finished, or says "done" when nothing shipped.
• It takes actions you never approved.

Quick start

npx delimit-cli setup

setup adds Delimit to the assistants it finds on this machine. Open your assistant as usual and it can read and write the same saved record. You can also save and find a decision from the terminal:

[Terminal recording: npx delimit-cli remember "Auth uses session cookies, not JWT. Decided after the token-leak review." prints "Remembered. (1 memory total)", then npx delimit-cli recall auth lists that same memory under "Delimit Memories" with the tag #jwt and "1 memory found (1 total)".]

The same session as text:

$ npx delimit-cli remember "Auth uses session cookies, not JWT. Decided after the token-leak review."
  Remembered. (1 memory total)
$ npx delimit-cli recall auth
  Delimit Memories
    [mem-9586382bff96] just now [cli] ✓    Auth uses session cookies, not JWT. Decided after the token-leak review.    #jwt
  1 memory found (1 total)

Works with: Claude Code, Codex, Cursor, and Antigravity (configured by setup), plus GitHub Copilot and Muse as full sessions through delimit chat. Install and sign in to each client yourself; see Lead chat, Copilot CLI and Muse Code sessions.

npx delimit-cli chat --model copilotnpx delimit-cli chat --model muse

Hard calls: npx delimit-cli deliberate "<question>" puts a question to the models you have configured (Claude, GPT via Codex, Gemini via Antigravity, Grok, DeepSeek, Muse) and shows you where they agree and where they disagree.

If Delimit helps you, a ⭐ helps other people find it.

For code repositories: merge gate

Delimit can also gate AI-assisted changes in a repository and keep a local signed attestation of each run.

$ delimit wrap -- claude "fix the flaky test in tests/api.spec.ts"
✓ repo_diagnose✓ security_audit       0 critical · 0 secrets✓ test_smoke           165/165✓ changed_files        1✓ attestation signed   att_a05050eb8e13277e                       delimit.attestation.v1 · HMAC-SHA256                       receipt → .delimit/attestations/att_a05050eb8e13277e.json

Every wrapped run emits a local delimit.attestation.v1 bundle: repo head before/after, changed files, gate results, and an HMAC-SHA256 signature. Verify it offline with delimit seal-verify; hosted replay is not available yet. Advisory by default; flip to enforcing when you're ready.

Zero-config PR check: delimit check

Zero-config PR safety gate. No init, no setup, no account, no keys — run it on any repo and it applies deterministic checks (breaking API changes + leaked secrets) to your staged or modified files.

npx delimit-cli check

$ delimit check
  Delimit Check
  Policy: default | Base: HEAD | Specs: 1
  + api/openapi.yaml — clean
  PASSED — no breaking changes, no leaked secrets

When a check finds a breaking change or a leaked secret, it prints the offending file and the issue and exits non-zero — so it drops straight into a pre-commit hook or CI step.

Common options:

delimit check --staged          # only check staged filesdelimit check --base main       # compare against a git ref (default HEAD)delimit check --fix             # show migration guidance for violationsdelimit check --record          # write a content-pinned record of this check

--record writes a content-pinned record of the check to .delimit/records/check-<ts>.json (or a path you name). That record is the precursor to the signed, replayable Seal attestation — the same evidence shape, pinned to the exact content you checked.

Methodology · cal.com v2 worked example · Workflow guide · Website

Worked examples

Real, reproducible merge-gate runs against public API specs:

• OpenAI OpenAPI: a year of AI frontier evolution under a cross-vendor merge gate — OpenAI (openai/openai-openapi)
• Stripe v1 OpenAPI: 57 days under a merge gate — Stripe (stripe/openapi)
• Anthropic API: 76 days under a cross-vendor merge gate — Anthropic (anthropics/anthropic-sdk-python)
• Twilio v2010 OpenAPI: 55 days under a merge gate — Twilio (twilio/twilio-oai)
• Docusign eSignature v2.1 OpenAPI: 46 days under a merge gate — Docusign (docusign/OpenAPI-Specifications)
• Supabase Auth OpenAPI: 57 days under a merge gate — Supabase Auth (supabase/auth)
• cal.com v2 OpenAPI: 60 days under a merge gate — cal.com (calcom/cal.com)
• EU TED v3 procurement API: $ref'd component-schema drift under a merge gate — European Commission (TED v3 Public API)
• Cross-agent handoff: one artifact, four CLIs — Cross-CLI session handoff (worked example)
• delimit-mcp-server (self-attestation): same merge gate, third artifact class — delimit-mcp-server (self-attestation)

See the full index at delimit.ai/reports. For the schema and signing methodology behind every report, see delimit.ai/methodology/mcp-attestation.

Golden Path — your first 10 minutes

The API check, end to end: lint a spec, see exactly what breaks, classify the bump, settle the hard calls with the model providers you configure, and keep a locally signed receipt of what ran. Then keep the context that survives across sessions and models.

1. Install

npx delimit-cli scan          # discovery: finds your OpenAPI specs, frameworks, security issues, testsnpx delimit-cli init          # wire up the merge-gate config (--preset strict | default | relaxed)

scan (delimit_scan) reports what Delimit can do for this repo. init (delimit_init) drops in the policy preset and merge-gate config. No account, no keys.

2. The merge gate, end to end

Lint the spec change (the gate). Baseline vs. proposed, with policy applied — one pass/fail verdict.

npx delimit-cli lint old.yaml new.yaml       # tool: delimit_lint

See exactly what breaks. Pure structural diff — added/removed/modified endpoints, schemas, params, no policy.

npx delimit-cli diff old.yaml new.yaml       # tool: delimit_diff

Classify the bump. Deterministic MAJOR/MINOR/PATCH/NONE — same input, same answer, every time.

delimit_semver       → MAJOR/MINOR/PATCH/NONE + next version stringdelimit_impact       → blast radius: scans your dependency manifest for downstream callers (informational)

Settle the hard calls. When the gate verdict is a judgment call, put it to multiple models and let them debate to consensus.

npx delimit-cli deliberate "Is dropping the deprecated v1 /users field a safe MINOR?"#   tool: delimit_deliberate — uses your configured model CLIs or API keys

delimit setup gives the Codex MCP server a 30-minute tool timeout so a multi-round panel can return its completed transcript instead of being detached by the client while its models are still responding.

Capture the signed, replayable attestation. After a gate event (deploy / security / test / audit), record the evidence bundle and verify it any time.

delimit_evidence_collect   → signed evidence bundle for the audit trail        (Pro)delimit_evidence_verify    → confirm a bundle hasn't been tampered with         (Pro)delimit_seal_verify        → check a Delimit Seal receipt against its bundled   (Free)                             Layer-0 constitution — offline-verifiable

Every receipt is offline-verifiable with npx delimit-cli seal-verify <receipt.json>. Hosted receipt replay is not available yet.

3. Context that survives sessions and models

Decisions, constraints, and tasks persist across sessions. Continue in Claude Code, Codex, Cursor, Antigravity, GitHub Copilot, or Muse with the saved record.

Memory — persist and recall the why, not just the diff.

npx delimit-cli remember "v1 /users field is frozen until Q3 — downstream billing depends on it"#   tool: delimit_memory_storenpx delimit-cli recall billing               # local recall over your saved memories (Free)

For semantic recall by meaning across sessions, the assistant calls delimit_memory_search (Pro) directly.

Ledger — one task list, shared across every assistant and session.

delimit_ledger_add        → record a task/bug/feature/strategic itemdelimit_ledger_context    → session-start: top open items by priority (what's queued)delimit_ledger_done       → close with a note (auto-captures a PR URL as ship proof)

That's the loop: gate the change, sign the proof, keep the context. Run it once on a real spec and you've used the whole merge gate.

Lead chat, Copilot CLI and Muse Code sessions

Install and authenticate the official client separately, under the same OS user who runs Delimit. Delimit does not install these clients, purchase a plan, log you in, or verify your subscription allowance. The interactive lead order is Claude → Codex → Antigravity → Muse → Copilot, subject to existing configuration, availability and native-client checks. This changes only lead chat, not review panels or background routing. Existing paid API fallback remains opt-in.

npx delimit-cli chatnpx delimit-cli chat --model musenpx delimit-cli chat --model copilotnpx delimit-cli chat --project /path/to/repository --model muse

You can launch from your home directory without changing directories. That is an unscoped owner workspace: Delimit loads workspace instructions but does not infer a venture or restore the newest unrelated handoff. A stale active-venture pointer is not selected. Use --project to bind an existing Git repository; missing or invalid project paths fail before launching a model. Root/workspace exit does not claim a project-bound capture. Recover or save continuity against the actual task scope through existing Delimit tools.

Muse and Copilot are native interactive harnesses, not new model votes or automatic build-loop backends. An explicit --model muse or --model copilot stays on that selection without probing or silently switching providers. In the default lead chain a failed native launch can advance to the next lead; an intentional interrupt exits. No successful handoff is inferred from a failed or unavailable capture. Native permission approvals remain active. Copilot launches with automatic updates and remote/export features disabled for this session.

Muse preparation: first verify that your account permits Standard muse-spark-1.3 on the intended billing route. Back up your native $XDG_CONFIG_HOME/muse/settings.json (or ~/.config/muse/settings.json when XDG_CONFIG_HOME is unset), and merge these fields into its existing JSON object; preserve unrelated settings and authentication:

{  "model": "muse-spark-1.3",  "context": {    "foreign_personal_rules": false,    "foreign_personal_skills": false  }}

The explicit Muse launch requires that selection and exclusion of foreign personal rules/skills; it does not change native settings for you. A configured provider must be meta, and a configured endpoint must be https://api.meta.ai/v1. META_API_KEY or MODEL_API_KEY environment overrides block this launch until you resolve the intended billing route. Do not switch credentials or models merely to bypass that check. Standard selection is not proof of zero retention, subscription billing, or private-data clearance.

Current binary discovery supports Copilot in ~/.local/bin, /usr/local/bin, or /usr/bin, and Muse's versioned ~/.local/bin/muse-bin-<version>-R<revision> distribution. Muse uses that executable directly, not its updater launcher. Other installation layouts are not automatically discovered. The native Muse context settings were checked with Muse Code 1.2.1; recheck compatibility when upgrading the client.

Delimit supplies a compact project-bound startup instruction, not an automatic import of your ledger, memory, or complete conversation. Optional local guidance can live in $DELIMIT_HOME/harness-bootstrap.md (default ~/.delimit/harness-bootstrap.md); the combined startup text must fit within 16 KiB. Project AGENTS.md/CLAUDE.md files at or above 64 KiB are rejected instead of silently truncated. Recover and save a scoped handoff through your available Delimit tools. These launchers do not automatically register a native MCP connection or prove cross-harness continuity.

When both project instruction files exist, the startup packet lists both files with their sizes and hashes and tells the harness to read them completely, including guidance hidden by native file precedence. It does not copy their contents into the startup packet, silently merge files, or override the existing instruction hierarchy. User-global guidance remains opt-in through the local bootstrap file; Delimit never copies a different client's private rules by default. This manifest is a loading instruction, not proof that the model performed every read. If required guidance is inaccessible or conflicts, resolve that gap before allowing edits. Oversized native project files still fail closed without rewriting the originals.

Optional command shims can be installed with delimit setup --harness-shims. Ordinary setup only refreshes already-managed Muse/Copilot shims; it does not newly shadow your native commands. Custom shims are preserved. With the opt-in, a conflicting custom file stops installation of both additional shims.

For existing launcher-managed continuity, clean exit finalizes only a bound handoff. If that is unavailable, Delimit reports the specific reason and writes a private local diagnostic receipt under its sessions/ directory. That receipt is not a conversation backup. Existing handoffs are not replaced by empty ones; resume the exact native session and explicitly save a project-bound handoff.

Think and Build

delimit think runs a multi-model deliberation using available configured providers. delimit build starts a detached planning worker that inspects the repository and writes briefs; it does not execute ledger tasks. delimit vault stores secrets as plaintext JSON in owner-only (0600) files.

Works across any configuration, from a single model on a budget to a full panel.

Try it in 2 minutes

npx delimit-cli doctor            # Checks your local setup and suggests fixesnpx delimit-cli status            # Visual dashboard of your entire governance setupnpx delimit-cli simulate          # Dry-run: see what would be blocked before you commitnpx delimit-cli scan              # Instant health grade for your API specnpx delimit-cli try owner/repo    # Try governance on any GitHub repo

No API keys. No account. No config files.

Pick your first win

Protect my API — catch breaking changes before merge:

npx delimit-cli try# Creates a sample API, introduces breaking changes, shows what gets blocked.# Saves a governance report to delimit-report.md

Watch for drift — detect spec changes without review:

npx delimit-cli init        # Sets up governance + drift baseline# Weekly drift checks run automatically via GitHub Action

Run PR copilot — governance gates on every pull request:

# .github/workflows/api-governance.yml- uses: delimit-ai/delimit-action@v1  with:    spec: api/openapi.yaml# Posts gate status, violations, and remediation in PR comments

What's New

Gate every AI-assisted invocation. Ship the receipts.

• delimit wrap — pipe claude -p, cursor, aider, codex, or any AI-assisted CLI through a signed governance gate. Snapshots the git diff before/after, runs lint + tests, HMAC-signs an att_* attestation, and writes the receipt locally for offline verification. Advisory by default; --enforce blocks CI on policy violations; --max-time <s> is a kill switch that tags the attestation as a liability_incident and prints a cross-model handoff command.
• delimit trust-page — renders a directory of attestations into a static HTML trust page + JSON Feed 1.1 feed. Single file, no framework, offline-renderable. Deploy anywhere.
• delimit ai-sbom — aggregates attestations into a CycloneDX 1.6 bill-of-materials with AI-specific fields (detected models per vendor, tool-call surface, policy gate counts). Pipe straight into procurement.
• Cross-model by construction — wrap uses the same local attestation schema across supported command-line producers. Delimit keeps session context across Claude Code, Codex, Cursor, Antigravity, GitHub Copilot, and Muse.

# Gate any AI-assisted CLIdelimit wrap -- claude -p "add tests for payments"#   → att_7d556843c84fb881 signed, receipt written locally
# Kill switch + handoff after 60s wall-clockdelimit wrap --max-time 60 -- cursor edit "refactor auth middleware"#   → if killed: kind=liability_incident#   → suggested: delimit wrap -- claude -p "refactor auth middleware"
# Render accumulated attestations as a public trust pagedelimit trust-page -o ./trust#   → ./trust/index.html (+ feed.json)
# Build a CycloneDX-AI bill of materialsdelimit ai-sbom -o ./ai-sbom.json#   → components: 4 models detected, 187 gates run

Earlier releases

The highest state of AI governance — earlier features still active.

• delimit doctor -- checks your local setup and suggests fixes. Supports --ci for pipelines and --fix for supported repairs.
• delimit simulate -- policy dry-run. See what would be blocked before you commit. The terraform plan for API governance.
• delimit status -- visual terminal dashboard. Policy, specs, hooks, CI, MCP, models, memory, ledger, evidence, git branch. --watch for live refresh.
• delimit report -- governance report. --since 7d --format md|html|json. Audit-friendly output for PRs and compliance.
• Memory hardening -- SHA-256 integrity hash + source model tag on every remember. Cross-model trust, verified on every recall.
• Tag-based publishing -- automated gateway sync, no more version drift between source and npm bundle.

Multi-Model Deliberation

Run your question through 4 AI models simultaneously. They debate each other until unanimous agreement.

delimit deliberate "Should we build rate limiting in-house or use a managed service?"

  Round 1 (independent):    Claude:  Build in-house. Redis sliding window is 50 lines.    Gemini:  Build. You already have Redis.    Codex:   Agree — but add circuit breaker for Redis failures.    Grok:    Build. Managed service costs $200/mo for 50 lines of code.
  Round 2 (deliberation):    All models: AGREE
  UNANIMOUS CONSENSUS (2 rounds, confidence 94/100)  Build rate limiting in-house with Redis + circuit breaker.

Deliberations use your configured model CLIs or API keys. Provider availability depends on your setup.

v4.18

• MCP Registry record published on every release -- the official registry entry now tracks the npm version automatically. Publisher pinned and checksum-verified; the tag gate asserts that both server.json version fields match the package version.
• Tool descriptions -- 16 previously undocumented parameters documented from their signatures; 26 Pro-gated tools state the prerequisite and the unlicensed-call response.
• Release guards -- bundle-classification guard no longer flakes on SIGPIPE.

v4.17

• Cross-model continuity on fresh installs -- delimit_soul_capture / delimit_revive work without any internal modules via the public session_continuity module; captured souls carry deterministic provenance (venture, transcript identity, capture key) for reliable resume across model switches. Existing soul files load unchanged.
• Security audit -- fewer false positives on test fixtures and documentation dummies; suppressed findings are reported, never silently dropped.

v4.16

• Fail-closed bundle allowlist -- the npm package ships only explicitly reviewed gateway files; two CI guards block any unclassified or non-allowlisted file from entering the tarball.
• Session-end auto-capture installs in the settings shape Claude Code expects, so end-of-session handoff fires instead of being silently dropped.
• Always-on commit-author audit workflow catches identity drift on the repo.

v4.1

• TUI -- terminal-native Ventures panel, real delimit think and delimit build commands
• Security hardening -- notify.py stubbed in npm, axios pinned against supply chain attacks
• Deliberation providers -- deliberations run on the model CLIs or API keys you configure (delimit models); no hosted runs are included
• Zero-config onboarding -- auto-detect framework, scan, and first evidence in one command
• Assistant permissions -- delimit setup configures MCP access for Claude Code, Codex, Cursor, and Antigravity and sets approval defaults for some clients; review these settings for your environment

v4.0

• Toolcard Delta Cache -- SHA256 schema hashing, delta-only transmission, saves tokens
• Session Phoenix -- cross-model session resurrection with soul capture
• Handoff Receipts -- structured acknowledgment protocol between agents
• Cross-Model Audit -- 3 lenses (security, correctness, governance) with deterministic synthesis
• 4-model deliberation -- Claude + Grok + Gemini + Codex debate until consensus
• Universal Swarm Triggers -- "Think and Build", "Keep building", "Ask Delimit"
• Full governance toolkit -- lint, diff, policy, evidence, drift, attestation, and swarm orchestration exposed as MCP tools and CLI subcommands

GitHub Action

Zero-config -- auto-detects your OpenAPI spec:

- uses: delimit-ai/delimit-action@v1

Or with full configuration:

name: API Contract Checkon: pull_request
jobs:  delimit:    runs-on: ubuntu-latest    permissions:      pull-requests: write    steps:      - uses: actions/checkout@v4        with:          fetch-depth: 0      - uses: delimit-ai/delimit-action@v1        with:          spec: api/openapi.yaml

That's it. Delimit auto-fetches the base branch spec, diffs it, and posts a PR comment with breaking changes, semver classification, migration guides, and governance gate results.

View on GitHub Marketplace | See a live demo (23 breaking changes)

Example PR comment

Breaking Changes Detected

Change	Path	Severity
endpoint_removed	DELETE /pets/{petId}	error
type_changed	/pets:GET:200[].id (string -> integer)	warning
enum_value_removed	/pets:GET:200[].status	warning

Semver: MAJOR (1.0.0 -> 2.0.0)

Migration Guide: 3 steps to update your integration

Governance Gates

Gate	Status	Chain
API Lint	Pass/Fail	lint -> semver -> gov_evaluate
Policy Compliance	Pass/Fail	policy -> evidence_collect
Security Audit	Pass	security_audit -> evidence_collect
Deploy Readiness	Ready/Blocked	deploy_plan -> security_audit

Adopt with minimum privilege

You don't have to trust a large tool surface on day one. The safe on-ramp:

Phase 1 — read-only governance (free, no account). Start with the tools that only read your repo and write reports: delimit_lint, delimit_diff, delimit_semver, delimit_policy, delimit_explain, delimit_scan, and delimit_seal_verify. If your MCP client supports per-tool allowlists, grant exactly those. Nothing in this set executes, deploys, or posts anywhere.

Phase 2 — opt into side effects deliberately. Tools that write evidence bundles, open PR comments, or run deploys (delimit_security_audit, delimit_deploy_*, agent orchestration) are tier-gated; enable them once phase 1 has earned its keep in your CI.

Pin the Action to a commit SHA. @v1 is a floating tag. For supply-chain-sensitive pipelines, pin the exact commit and bump on review:

- uses: delimit-ai/delimit-action@<commit-sha>   # gh api repos/delimit-ai/delimit-action/git/refs/tags/v1

Keep BYOK keys out of repo and dotfile config. If you bring your own model keys for deliberation, store them with delimit_secret_store (kept locally in owner-only 0600 files, base64-encoded, not encrypted; access-logged via delimit_secret_access_log) rather than in dotfiles.

Our own releases ship under the same discipline: every release carries a signed, replayable Seal receipt (see the latest release assets — verify with npx delimit-cli seal-verify <receipt.json>), plus SLSA provenance on npm.

CLI commands

npx delimit-cli scan                             # Instant spec health grade + recommendationsnpx delimit-cli pr owner/repo#123                # Review any GitHub PR for breaking changesnpx delimit-cli quickstart                       # Clone demo project + guided walkthroughnpx delimit-cli try                              # Zero-risk demo — saves governance reportnpx delimit-cli demo                             # Self-contained governance demonpx delimit-cli init                             # Guided wizard with compliance templatesnpx delimit-cli init --preset strict             # Initialize with strict policynpx delimit-cli setup                            # Install into all AI assistantsnpx delimit-cli setup --dry-run                  # Preview changes firstnpx delimit-cli lint api/openapi.yaml            # Check for breaking changesnpx delimit-cli diff old.yaml new.yaml           # Compare two specsnpx delimit-cli explain old.yaml new.yaml        # Generate migration guidenpx delimit-cli check                            # Pre-commit governance checknpx delimit-cli check --staged --fix             # Check staged files + show guidancenpx delimit-cli hooks install                    # Install git pre-commit hooknpx delimit-cli hooks install --pre-push         # Also add pre-push hooknpx delimit-cli ci                               # Generate GitHub Action workflownpx delimit-cli ci --strict --dry-run            # Preview strict workflownpx delimit-cli remember "Redis uses JWT 15min"   # Save a persistent memorynpx delimit-cli recall redis                     # Search memoriesnpx delimit-cli recall                           # Show recent memoriesnpx delimit-cli recall --tag deploy --all        # Filter by tag, show allnpx delimit-cli recall --export                  # Export as markdownnpx delimit-cli forget abc123                    # Delete a memory by IDnpx delimit-cli models                            # Configure deliberation API keys (BYOK wizard)npx delimit-cli models --status                   # Show current model confignpx delimit-cli status                           # Compact dashboard of your Delimit setupnpx delimit-cli doctor                           # Check setup healthnpx delimit-cli uninstall --dry-run              # Preview removalnpx delimit-cli wrap -- claude -p "..."          # Gate any AI-assisted CLI + signed attestationnpx delimit-cli wrap --max-time 60 -- codex "..."# With kill switch + handoff on timeoutnpx delimit-cli trust-page -o ./trust            # Render attestations into a static trust pagenpx delimit-cli ai-sbom -o ./ai-sbom.json        # Build a CycloneDX-AI bill of materials

What the MCP toolkit adds

When installed into your AI coding assistant, Delimit provides tools across two tiers:

Free (no account needed)

• API governance -- lint, diff, policy enforcement, semver classification
• Persistent ledger -- track tasks across sessions, shared between all AI assistants
• Zero-spec extraction -- generate OpenAPI specs from FastAPI, Express, or NestJS source
• Project scan -- auto-detect specs, frameworks, security issues, and tests
• Quickstart -- guided first-run that proves value in 60 seconds

Pro

• Multi-model deliberation -- the models you configure debate until they agree; provider availability depends on your setup
• Security audit -- dependency scanning, secret detection, SAST analysis
• Test verification -- confirms tests ran, measures coverage, generates new tests
• Memory & vault -- persistent context and local plaintext secret files across sessions
• Evidence collection -- governance audit trail for compliance
• Deploy pipeline -- governed build, publish, and rollback
• OS layer -- agent identity, execution plans, approval gates

What It Detects

Delimit checks OpenAPI and JSON Schema changes using deterministic rules for the cases each surface supports. Examples include removed endpoints, newly required parameters, and changed response fields. Review the result alongside your contract; rule coverage differs between the CLI and GitHub Action.

Policy presets

npx delimit-cli init --preset strict    # All violations are errorsnpx delimit-cli init --preset default   # Balanced (default)npx delimit-cli init --preset relaxed   # All violations are warnings

Or write custom rules in .delimit/policies.yml:

rules:  - id: freeze_v1    name: Freeze V1 API    change_types: [endpoint_removed, method_removed, field_removed]    severity: error    action: forbid    conditions:      path_pattern: "^/v1/.*"    message: "V1 API is frozen. Changes must be made in V2."

Supported formats

• OpenAPI 3.0 and 3.1
• Swagger 2.0
• YAML and JSON

FAQ

How does this compare to Obsidian Mind?

Obsidian Mind is a great Obsidian vault template for Claude Code users who want persistent memory via markdown files. Delimit takes a different approach: it keeps a shared record across Claude Code, Codex, Cursor, Antigravity, GitHub Copilot, and Muse. Your memory, ledger, and governance travel with you when you switch models. Delimit also adds API governance (breaking-change detection for OpenAPI specs), CI gates, git hooks, and policy enforcement that Obsidian Mind doesn't cover. Use Obsidian Mind if you're all-in on Claude + Obsidian. Use Delimit if you switch between models or need governance.

Does this work without Claude Code?

Yes. Delimit supports Claude Code, Codex, Cursor, Antigravity, GitHub Copilot, and Muse. The remember/recall commands work standalone. The MCP server integrates with clients that support the Model Context Protocol.

Is this free?

Delimit lists Free, Pro, and Enterprise plans. Multi-model deliberation uses your configured model CLIs or API keys. See current plan details.

Local data and network calls

Delimit stores its ledger, records, and local attestations on your machine. Some setup and session paths make network requests by default:

• Setup checks for a newer CLI release and can download the Pro module tarball.
• The Claude Code SessionStart hook and installed shims can check for and install updates.
• License activation contacts the license provider and sends your customer email, license ID, and machine hash to delimit.ai.
• Multi-model deliberation sends your prompt and relevant context to the model providers you configure, through your CLI logins or API keys.

gateway/ai/supabase_sync.py is not bundled with this package. Webhook notifications are sent only when DELIMIT_WEBHOOK_URL is configured.

Links

• delimit.ai -- homepage
• Dashboard -- governance console
• Docs -- full documentation
• GitHub Action -- Marketplace listing
• Quickstart -- try it in 2 minutes
• npm -- CLI package
• Pricing -- free tier + Pro

MIT License