More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Warden Guardrails

    1

    An offline MCP server and skill for coding agents. Before your agent says done, warden runs the check you named in warden.json, once, and answers backed or unbacked with the exact failing lines. Optional: jev rules judge

    $20

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Warden Guardrails

    Example session with this skill installed

    In this project, orders over $100 get 10% off. Add that, show the discount in describeOrder(), and log the order total when the discount applies.

    • Read your context and instructions
    • Compiled the warden guardrails

    The commit warden refused

    Recorded on 2026-10-28: Pi 1.4.0, model deepseek/deepseek-v4-pro, thinking level high, on macOS 27.2 (arm64) with
    Node 26.12.1 and git 2.54.0. The session had no warden MCP server, no warden skill and no warden tool of any kind —
    read, bash, edit and write were the only tools it had — and one thing installed: warden hook install. The
    project has six rules in pi-warden.md and a judge in warden.json: TypeSafe at api.typesafe.ai, model
    jev-latest, 8 requests and $0.05 a day.

    The task was 10% off orders over $100, shown in describeOrder(), with the order total logged when the discount
    applies. The agent opened pi-warden.md and warden.json, wrote the discount, and also rewrote orderTotalCents, a
    function the task never mentions. Then it staged and committed:

    $ git add src/orders.js i18n/en.json test/orders.test.js && git commit -m "Add 10% discount for orders over \$100"
    judge: typesafe at api.typesafe.ai, model jev-latest, key in TYPESAFE_API_KEY
    sent: one request holding the staged diff of 3 paths and 6 rules in pi-warden.md that govern them. Nothing else was read or sent.
    paths: apps/shop/i18n/en.json, apps/shop/src/orders.js, apps/shop/test/orders.test.js
    rules asked: 6, in one request (maxQuestions 8, pi-warden.md)
    check-change: the staged change breaks 1 of 6 rules in pi-warden.md that govern it.
    violation (violation probability 0.72): "Change only what the task needs" (pi-warden.md line 10)
    steer: The change to apps/shop/src/orders.js (staged) breaks project rule "Change only what the task needs" (pi-warden.md line 10). Fix it in your next edit.
    The commit is blocked until the rule break is fixed: edit, `git add` the fix, commit again.
    budget: 7 of 8 requests and $0.049848 of $0.05 left today (2026-10-28).
    

    git commit exited 1 and no commit was made. The agent left orderTotalCents alone and moved the discount into
    describeOrder(), then ran the same commit command again:

    judge: typesafe at api.typesafe.ai, model jev-latest, key in TYPESAFE_API_KEY
    sent: one request holding the staged diff of 3 paths and 6 rules in pi-warden.md that govern them. Nothing else was read or sent.
    paths: apps/shop/i18n/en.json, apps/shop/src/orders.js, apps/shop/test/orders.test.js
    rules asked: 6, in one request (maxQuestions 8, pi-warden.md)
    pass: no rule broken
    budget: 6 of 8 requests and $0.049703 of $0.05 left today (2026-10-28).
    [main e47b4ae] Add 10% discount for orders over $100
     3 files changed, 39 insertions(+), 2 deletions(-)
    

    Two requests left the machine in the whole recording, both to api.typesafe.ai, one per commit; the ledger counted 2
    started and 2 succeeded, 7,081 input tokens, $0.000297 estimated. The full session, every message and tool call, is in
    docs/demo.md.

    What this does not show. The agent read pi-warden.md before it edited, so this is not a session that worked in the
    dark: it is one where the rule was in front of the agent and was broken anyway, which is what a commit check is for. It
    also does not show a refused commit from any client but Pi, or the same hook on Linux.

    The earlier recorded sessions

    Before the hook existed, three sessions with the warden MCP server and the skill stayed compliant. The first, also on
    2026-10-28 with model deepseek/deepseek-v4-pro, worked on a small storefront module whose strings live in
    i18n/en.json. One project rule says every string a shopper sees comes from i18n/en.json, and the task added two such
    strings.

    Before its edit, the agent called rules_for_path for src/cart.js, and got the rule that the task put at risk:

    5. # Every user-facing string comes from i18n/en.json (pi-warden.md line 17)
       scope: src/**/*.js
       text: Text a shopper can see is looked up with `t()` from i18n/en.json. Never write it as a literal in code.
    

    It wrote both strings through t(), and called rules_judge before writing, which answered no violation for both
    files, with two requests to api.typesafe.ai (model jev-latest, answered by jev-1.14.0). It ran npm test, called
    done_check, and its claim came back backed.

    One misstep is in that transcript: the agent read the budget line as nearly spent and skipped a test for the new
    behaviour. Two later sessions, on a project whose rule asks for a test with every new exported function, also stayed
    compliant: the agent wrote the test both times and never called rules_judge. None of those three sessions produced a
    break for a judge to find.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Inconsistent adherence to project rules leads to technical debt and broken builds. This skill enforces local project constraints through a deterministic MCP server that intercepts edits and commits.

    What it does

    • Rule Enforcement fetches path-specific constraints from pi-warden.md before any file edit.
    • Verification Hook validates claims of completion by executing project-defined check commands.
    • Failure Recovery analyzes repeated command errors to detect loops and suggest new hypotheses.
    • Prose Optimization reviews READMEs, commit messages, and PR descriptions for clarity and project style.
    • Commit Guarding installs a pre-commit hook that judges staged changes against the global rule set.

    How it works

    1. Initialization run init via the local Node CLI to generate warden.json and detect your project's test suite.
    2. Registration add the MCP server to your environment (Claude Code, Cursor, or Codex) using the provided absolute paths.
    3. Active Guarding the agent calls rules_for_path before modifying files and done_check before reporting status.
    4. Automated Judging if configured, the system uses an LLM judge to verify code changes against complex logical constraints.

    Frameworks & tools

    Built for Node.js (22.19+) environments. Integrates with Git via pre-commit hooks and supports any CLI-based test runner (npm, pytest, cargo) through warden.json configuration.

    Why this beats prompting it yourself

    Generic prompts often ignore local project context or "hallucinate" that a test passed. This skill uses a local, deterministic server to bind the agent's actions to your actual filesystem and test results, ensuring rules are checked every time without manual reminders.

    In 14,322 recorded sessions of the tool, 3,842 of 5,130 "done" claims had no check command configured at all, 75% of the times an agent said it was finished, nothing had been run. That is the gap this skill closes: one command, run once, quoted.

    Use cases

    • Preventing agents from violating architectural patterns in specific directories.
    • Automating the verification of bug fixes before they are reported as resolved.
    • Blocking invalid commits through a local Git hook that runs on every save.
    • Ensuring technical documentation follows project-specific voice and tone guidelines.

    Known limitations

    Requires Node.js 22.19 or newer. Tools are local only; the rules_judge feature requires a user-provided LLM API key configured in warden.json to function.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Requires Node.js 22.19+. Judge tool requires manual LLM API key setup in warden.json. Git hooks require local repository access.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 20 days ago

    Accounts
    GitHubIetfMathiasbynensSafaribooksonlineOpenapisTypesafeOpenrouterCommandcodeLiquidSubq
    Software
    Node.jsGitConfig MCPSession Id MCP

    Permissions

    Read Files
    Write Files
    Network Access
    Environment Variables
    Terminal / Shell

    Allowed Hosts

    raw.githubusercontent.com
    json-schema.org
    tools.ietf.org
    gist.github.com
    mathiasbynens.be
    www.safaribooksonline.com
    spec.openapis.org
    github.com
    stackoverflow.com
    www.w3.org
    api.typesafe.ai
    openrouter.ai
    example.com
    api.commandcode.ai
    api.liquid.ai
    api.subq.ai
    Listed20 days ago

    What's inside

    Frequently Asked Questions

    It gives your agent six offline tools and a skill that says when to use them: before editing a file it reads the rules that govern that file; before saying done it runs the check you named, once, and gets backed or unbacked with the exact failing lines; a commit that breaks a rule is refused by a local git hook. Every tool is deterministic, same input, same answer, except the optional judge, which needs your own key.

    Any client that starts MCP servers over stdio, including Claude Code, Cursor, Codex, GitHub Copilot in VS Code and Pi; the quickstart ships a config for each. The skill follows the open SKILL.md standard. Node.js 22.19 or newer, no install step beyond unzipping.

    One command: warden init detects your check command, then writes warden.json and pi-warden.md. Add the single line doctor prints to your agent's MCP config (warden mcp serve), and optionally run warden hook install so every commit is judged. Remove the hook with rm .git/hooks/pre-commit.

    Yes, for human commits too: the hook runs on every git commit, whoever made it. Note the switch, it judges only when you have configured a judge in warden.json and put its key in the environment. With no judge, every commit passes untouched; with one, a commit that breaks one of your rules is refused, the rule is named and the agent gets a fix instruction. Rules are scoped per path in pi-warden.md, not global.

    You receive the full MCP server package, the Node CLI for initialization and management, and the pre-commit hook integration scripts. Please note that while the core verification is deterministic, the optional `rules_judge` feature requires your own LLM API key.

    New in LLM Ops