writ-mcp
OfficialSummary: writ-mcp is an MCP server that lets agents gate consequential writes through Writ’s policy engine, receive allow/deny/step-up decisions, verify authorization, execute approved upstream calls, and manage audit and tenant administration.
Gate consequential actions with
writ_check, returningALLOW,DENY, orSTEP_UPplus an audit receipt.Verify short-lived auth tokens immediately before executing an allowed write using
writ_verify_token.Convert
ALLOWtokens into single-use leases and execute gated upstream requests to Stripe, GitHub, or Salesforce withwrit_leaseandwrit_execute.Approve step-up requests with
writ_grant, and usewrit_revoke/writ_reinstateas a kill switch.Read and verify the tamper-evident receipt hash chain, and explain individual receipts in plain language.
Inspect tenant policy, principals, verb vocabulary, and API key metadata.
Run a keyless sandbox demo of the check/verify flow.
Manage GitHub App installations, scan fail thresholds, PR-comment settings, and scanned repo risk manifests.
Configure step-up notifications, mint/rotate tenant invite codes, join tenants, and mint/revoke README badge tokens.
Integrates with the Writ GitHub App to list connected installations, configure per-installation check-run failure thresholds for ungated write sites, and enable or disable the PR-comment bot.
pywrit
Find the dangerous writes in your Python agent's code, then gate it. pywrit is the Python
client and writ CLI for Writ: an allow/deny gate that sits
in front of your agent's consequential writes (database, HTTP, files, email, queues,
AWS) and records a hash-chained receipt for every decision.

writ scan is local, deterministic, and free: it parses your code with Python's
ast module, makes no network calls, and needs no API key.
Install
pip install pywritRequires Python 3.9+. Installs the writ command and the pywrit Python client.
JavaScript/TypeScript devs: run the scanner with no Python setup via npm:
npx writ-scan .The writ-scan package wraps the same scanner (including TS/JS support). On
first run it installs pywrit[polyglot] from PyPI using your Python 3.9+
(one-time); afterwards it starts instantly. See npm/ for details,
environment overrides (WRIT_PYTHON, WRIT_SCAN_NO_INSTALL), and the
install test.
Related MCP server: Vorim AI — Agent Identity & Trust
Language coverage
Language |
|
| Notes |
Python | Yes | Yes, inserts | Parsed with the stdlib |
TypeScript / JavaScript | Yes, with | No, scan only | Needs the extra: |
Go | Yes, with | No, scan only | First detection family plus request-pipeline Call/RawRequest, package-level generated clients, and GORM Raw raw-SQL writes: database/sql Exec/ExecContext, GORM Create/Save/Update/Updates/Delete, HTTP client writes and http.NewRequest with a write method, generated-client ..<New|Update|Delete|Create>, request-pipeline X.Call/X.RawRequest with a write method, package-level generated clients .<New|Update|Delete|Create> on an imported resource-shaped package, GORM Raw |
60-second quickstart: scan → wrap → gate
1. Scan. See which functions write, and how many of them are gated.
writ scan .writ scan: /path/to/support-agent
files scanned: 4 skipped: 0
write sites: 4 in 3 function(s)
gated: 0/4 (0%)
verbs discovered: 3
crm.update
payments.refund
tickets.closeIt also prints a risk report (0-100, weighted by risk tier), writes the discovered
verbs to writ-policy.json, and shows the instrumentation it would add as a unified
diff. Nothing in your code changes yet. writ scan . --score prints just the risk report.
2. Wrap. One command takes the repo from unwrapped to wrapped: scan, show the diff, ask for explicit approval, apply the gates, and report before/after coverage.
writ wrap . # interactive approval
writ wrap . --yes # no prompt (e.g. in CI)--dry-run previews the plan and exits before prompting; --diff-only prints the
unified diff for review tools. Each gated function now asks Writ before it writes, and
fails closed:
def issue_refund(charge_id, amount_cents):
if _writ_check("payments.refund") != "ALLOW":
raise PermissionError("writ denied payments.refund")
...writ scan . --apply is still available as the manual alternative. Re-run writ scan .
and you'll see gated: 4/4 (100%).
3. Gate. Get a free API key, load the discovered policy, and run your agent.
writ key --email you@example.com # free API key + tenant
export WRIT_API_KEY=writ_... # read by the inserted gate
export WRIT_SPONSOR=acme WRIT_AGENT=support-agent # optional: who is acting
writ scan . --push-policy --key "$WRIT_API_KEY" # upload the discovered verb policyEvery gated write now gets ALLOW, DENY, or STEP_UP (a human sponsor must
approve), and every decision is written to your tenant's tamper-evident audit log:
writ receipts --key "$WRIT_API_KEY" # latest receipts
writ verify-chain --key "$WRIT_API_KEY" # verify the receipt hash chain
writ stream --key "$WRIT_API_KEY" # tail decisions live
writ report --key "$WRIT_API_KEY" # Agent Action ReportWhat writ scan detects
Python (.py) files, parsed with the stdlib ast (no extra dependencies):
Category | Examples |
Database |
|
HTTP |
|
Files |
|
| |
Queues |
|
AWS SDK |
|
Each write is mapped to a verb such as
payments.refundorcrm.update, inferred from the file path and function name.A function that already calls
writ_check(...)/_writ_check(...)counts as gated.Skipped: tests, hidden directories, virtualenvs,
node_modules,dist,build. Use--exclude SUBSTR(repeatable) to skip more.Not covered (review by hand): writes behind dynamically built SQL, third-party SDK calls such as
stripe.Refund.create(...), deferred task queues, or shared clients several layers down. The risk report lists these gaps every time.
TypeScript / JavaScript (scan-only)
writ scan also finds write sites in TypeScript and JavaScript. It needs the
optional extra (tree-sitter based):
pip install 'pywrit[polyglot]'
writ scan .Without the extra, the scanner prints a prominent warning block naming the unscanned TS/JS files and keeps going — Python scanning never needs it.
Findings from non-product paths (docs/, scripts/, sandbox/, examples/,
benchmark/, demo/, and build-tooling files such as gulpfile.js or
webpack.config.*) are suppressed by default: the report counts them per
class and names every suppressed path instead of listing them as findings.
Pass --include-non-product to report them like any other finding.
Every scan report ends with a one-line pointer to the Writ GitHub App
(install: https://github.com/apps/writ-scanner, guide:
https://docs.withwrit.com/git-hub-app), which runs the scan on every push
and pull request; the JSON report (--format json) carries the same
pointer under github_app.
TS/JS is scan-only: findings are listed with verbs for your policy file,
but writ scan --apply never rewrites TS/JS files — gate those by hand.
Covered patterns: fetch/axios writes, fs writes, SQL through knex-style
clients, Prisma writes, JS SDK calls such as stripe.refunds.create(...), and
generated REST resource clients: create / update / patch / remove
methods (plus their ...WithHttpInfo variants) that build request options
with an explicit write HTTP method and route them through the client request
pipeline (twilio-style generated clients, e.g. twilio-node).
(Still not covered: the Python SDK equivalents like stripe.Refund.create(...)
— see "Not covered" above.)

Go (scan-only)
writ scan also finds write sites in Go. It needs the optional extra (tree-sitter based):
pip install 'pywrit[polyglot]'Covered in this first family plus request-pipeline and package-level generated-client detection: database/sql Exec / ExecContext, GORM Create / Save / Update / Updates / Delete, HTTP client Post / Put / Patch / Delete and http.NewRequest / NewRequestWithContext with a write method, generated-client calls shaped <client>.<Resource>.<New|Update|Delete|Create> with an uppercase resource segment (the stripe-go shape), request-pipeline calls X.Call(method, ...) / X.RawRequest(method, ...) where argument 0 is a write method (the stripe.Backend shape, e.g. c.B.Call(http.MethodPost, "/v1/accounts", ...)), and package-level generated-client calls <pkg>.<New|Update|Delete|Create>(...) where <pkg> is imported in the file and the import path's last segment is resource-shaped, not structy (params, config, ...) and not service-, client-, library-, or test-double-shaped (svc, service, client, api, sdk, internal, mock, fake). This is the pre-v87 stripe-go shape (charge.New(params)), aliased imports included: the guard reads the import path, so acmeinvoice "example.com/acme/acme-payments/invoice" fires while paymentsvc.New(cfg) does not. GORM raw-SQL calls db.Raw("INSERT INTO ...") / tx.Raw("DELETE FROM ...") fire when argument 0 is a string literal (interpreted or backtick) whose first keyword is a write verb (INSERT, UPDATE, DELETE, REPLACE, TRUNCATE, MERGE), case-insensitive; a variable, a read-first literal (SELECT), a leading WITH (CTE), or a Raw call on a non-db/tx receiver never fires. GET/HEAD requests, db.Query / QueryRow, bare constructors (.New on a local variable or on an imported service- or structy-shaped package), and pipeline calls with a variable method or a non-method first argument are not flagged. _test.go files and vendor/ trees are skipped. Go is scan-only: writ scan --apply never rewrites .go files, gate those by hand. Not yet covered: WITH-CTE raw-SQL writes and other Go write patterns.
GitHub Action
Scan every pull request for ungated write sites. Findings land as check
annotations on the exact file and line, plus a Markdown risk report in the
job summary. The check fails when an ungated finding meets your
fail-on-risk threshold (default: high).
- uses: actions/checkout@v4
- uses: withwrit/pywrit@v0
with:
fail-on-risk: high # high | medium | low | neverNo API key needed. Full reference: docs/github-action.md · example workflow: examples/github-action/writ-scan.yml
GitHub App
Install the Writ GitHub App on selected repositories: every push and pull request is scanned for ungated write-sites, with results as a check run on the PR and in the portal, where you manage policy, keys, and the audit log. Setup and data handling: GitHub App docs.
MCP server (writ-mcp)
Give any MCP-compatible agent point-of-action policy checks. writ-mcp is a
Model Context Protocol server (stdio transport,
built on the MCP Python SDK) that exposes the Writ gate as 24 MCP tools:
the agent calls writ_check before a consequential write and gets back ALLOW,
DENY, or STEP_UP — with a tamper-evident, hash-chained audit receipt for
every decision.
uvx writ-mcp # no install — runs on demand
# or
pip install writ-mcp # then run `writ-mcp`Tool | What it does |
| The gate: |
| Validate an |
| Convert an |
| Run one gated upstream request with a lease or |
| Human-sponsor approval for the |
| The kill switch |
| Read the tenant's audit log |
| Verify the audit-log hash chain |
| Manage the verb policy |
| Keyless 90-second demo grant — no API key needed |
| List connected GitHub App installations |
| Set the check-run fail threshold per install |
| Enable/disable the PR-comment bot |
| List repos with risk profiles or fetch one manifest |
| Explain a receipt in plain language |
| Get or update step-up notification settings |
| List the tenant's principals |
| List the tenant's verb vocabulary |
| List API key metadata |
| Mint a public README badge token |
| Revoke a badge token; its badge image URL 404s |
| Mint/rotate the tenant's one live team invite code (writ_inv_...) |
| Join a tenant with an invite code; issues an API key, no key needed first |
The gate tools need a free Writ API key (WRIT_API_KEY): 10,000 receipts/month
free, no credit card. writ_sandbox works with no key at all.
The server implementation lives in mcp/ (MIT). Also published on the
official MCP Registry as io.github.withwrit/writ and listed on
Glama.
Python client
from pywrit import WritClient
client = WritClient(api_key="writ_...")
result = client.check(
sponsor_id="acme",
agent_id="agent-7",
verb="db.write",
target="prod.customers",
purpose="backfill region field",
)
if result.decision == "ALLOW":
# result.auth_token is a short-lived token bound to this exact write
perform_write(...)
elif result.decision == "STEP_UP":
# a human sponsor must approve first: client.grant(...), then re-check
...
else:
# DENY
...No API key yet? Try the keyless sandbox:
client = WritClient()
client.sandbox({
"sponsorId": "acme",
"agentId": "agent-7",
"verb": "demo_write", # sandbox only allows demo_write ...
"target": "demo-customers", # ... on targets starting with demo-
"purpose": "trying the gate",
})What's covered:
check(...): the gate.ALLOW/DENY/STEP_UP, plus a receipt every timeverify_token(...): validate anALLOWauth token (catches purpose drift)grant(...): human-sponsor approval for theSTEP_UPpathget_policy()/set_policy(...): manage the tenant policyrevoke(...)/reinstate(...)/revoked(): the kill switchreceipts()/receipt(id)/verify_chain()/stream_receipts(): the audit logsandbox(...): keyless trial, no API key required
CLI reference
writ wrap . # scan, diff, approve, apply, verify coverage
writ wrap . --dry-run # preview only
writ wrap . --yes # non-interactive CI mode
writ check --key writ_... --sponsor acme --agent agent-7 \
--verb db.write --target prod.customers --purpose "backfill region field"
writ policy --key writ_... --set payments.refund require_grant
writ revoke --sponsor acme --agent agent-7 --reason "runaway loop" # kill switch (sponsor token)
writ grant --sponsor acme --agent agent-7 --verb payments.refund \
--target ch_123 --purpose "approved refund" # STEP_UP approval (sponsor token)Sponsor-token commands (revoke, reinstate, revoked, grant) read
--sponsor-token or WRIT_SPONSOR_TOKEN. Run writ --help for the full command list.
README badge
Show that your agent's writes are gated by Writ. Two flavors:
Static (works today, no API key) — same design, no live count:
[](https://withwrit.com)Dynamic (live 30-day gated-write count from your audit log) — mint a badge token, then embed the snippet the API returns:
curl -s https://api.withwrit.com/v1/badge/tokens \
-H "Authorization: Bearer writ_..." \
-H "Content-Type: application/json" \
-d '{}'The dynamic endpoint ships with the gate — until it's live, POST /v1/badge/tokens
returns 404 and the static badge above is the one to use.
See badge/ for embed docs and the verification model (what the
badge proves — and what it doesn't).
Docs
Full docs: docs.withwrit.com · Quickstart: docs.withwrit.com/quickstart · Site: withwrit.com
License
MIT
Available Tools
24 toolswrit_badge_revokeA
Revoke one of the tenant's badge tokens.
Its badge image URL 404s from that moment on, so embeds show a broken image rather than a stale claim. Only tokens belonging to the caller's tenant can be revoked.
Args: badge_token: The writ_badge_ token to revoke (shown once at mint time).
Inputs: badge_token (required). Returns: result
writ_badge_tokenA
Mint a public badge token for the tenant and return its embed snippet.
The badge renders the tenant's live gated-write count over the trailing 30 days. The token is shown exactly once: store it, it is needed to revoke the badge. It is public by design (it lives in a README image URL) and cannot be used as an API key. See https://docs.withwrit.com/readme-badge for the verification model.
Args: label: Optional private label for your own bookkeeping (max 40 chars, letters/digits/space/_/.-). Never rendered on the badge.
Returns the gate payload verbatim: badgeToken (writ_badge_...), badgeUrl, markdown (ready-to-paste README snippet), label, and a note.
Inputs: label. Returns: result
writ_checkA
Ask Writ whether an action may proceed. CALL THIS BEFORE any consequential write.
A consequential write is anything hard to undo: sending money or messages, changing access or identity records, deleting data, calling an external API that acts in the world.
Args: sponsor_id: The human sponsor accountable for this action (e.g. a user id or email). agent_id: The agent or workflow performing the action. verb: What is being done (e.g. "verify_human", "send_payment"). target: What it acts on (e.g. "benefit-case-123"). purpose: Why, in plain words. Be specific — the approval is bound to this purpose. environment: Optional policy environment: "dev", "staging", or "prod". The check runs against that environment's policy override (verbs it doesn't override inherit the tenant default). Omit for the tenant default. An unknown name denies fail-closed — never silently falls back.
Returns a decision: ALLOW — proceed. You get an authToken valid 90 seconds, bound to this exact sponsor/agent/verb/target/purpose. Call writ_verify_token against the intended write immediately before executing it. DENY — do NOT perform the action. Explain the receipt reason to the user. STEP_UP — a human sponsor must approve first. Tell the user what needs approval; they can approve via writ_grant (or the dashboard), then call writ_check again. Every outcome creates an audit receipt with a receiptId.
Inputs: verb (required), target (required), purpose (required), agent_id (required), +2 more. Returns: result
writ_executeA
Run one gated upstream request with a lease or ALLOW token.
Pass exactly one of lease_id (from writ_lease) or auth_token (from a writ_check ALLOW). Pass the SAME method, path, and body as the lease: the gate compares the request bytes against the lease, and on any mismatch it fails closed: no upstream call is made and the answer is {"ok": false, "reason": ..., "upstreamCalled": false}.
Args: lease_id: The leaseId from writ_lease. Mutually exclusive with auth_token. auth_token: An ALLOW authToken from writ_check. Mutually exclusive with lease_id. system_id: The registered upstream system: "stripe" (default), "github", or "salesforce". method: HTTP method of the upstream request (required, e.g. "POST"). path: Upstream path (required, e.g. "/v1/refunds"). body: Optional JSON object. Must be byte-identical to the leased body. idempotency_key: Optional key passed through to the upstream system. Use it so retries are safe.
On success the gate returns the upstream system's status and body verbatim. Every outcome writes a receipt. On {"ok": false} report the reason to the user and do NOT retry with a different request: the lease is spent or invalid.
Inputs: body, path, method, lease_id, +3 more. Returns: result
writ_explain_receiptA
Fetch a receipt and explain it in plain language.
Use this to understand why a writ_check returned ALLOW, DENY, STEP_UP, or REVOKED. Returns the receipt with a human-readable breakdown.
Inputs: receipt_id (required). Returns: result
writ_github_installationsA
List the GitHub App installations for this tenant.
Returns each installation's id, status, PR-comment bot setting, and the per-installation check-run fail threshold (checkFailUngated). Use this to discover installation ids before calling writ_github_set_threshold or writ_github_toggle_pr_comments.
Inputs: no named parameters. Returns: result
writ_github_set_thresholdA
Set the per-installation check-run fail threshold.
A positive number N makes the GitHub check run fail when the ungated-site count is greater than N; a zero-ungated scan passes. Omit threshold (or set it to None) to clear the override and restore neutral-only check runs.
Inputs: installation_id (required), threshold. Returns: result
writ_github_toggle_pr_commentsA
Enable or disable the optional PR-comment bot for a GitHub App installation.
Default is OFF. No TOTP step-up is required. Use writ_github_installations to find installation_id.
Inputs: enabled (required), installation_id (required). Returns: result
writ_grantA
SPONSOR ONLY. Mint a one-time grant approving a specific action.
Use this when writ_check returned STEP_UP and the human sponsor approves. The grant is single-use: the next writ_check consumes it and returns ALLOW. The grant is scoped to your tenant. Requires WRIT_SPONSOR_TOKEN.
Inputs: verb (required), target (required), purpose (required), agent_id (required), +2 more. Returns: result
writ_join_tenantA
Join an existing Writ tenant with a team invite code. No API key needed.
This is the join flow: the endpoint is unauthenticated (the caller has no key yet, that is the point) and issues a fresh API key on the invited tenant instead of creating a new one. This tool is not general key issuance: invite_code is required.
Args: email: Contact email for the new key. invite_code: The team's live writ_inv_... code (from writ_tenant_invite, shared by a teammate). tenant_name: Optional display name; only sent when non-empty.
Returns the gate payload verbatim: apiKey, tenantId, plan, monthlyChecks, defaultPolicy, and sponsorToken only when present. Store the apiKey immediately: it is shown once. Joining members receive NO sponsor token; only the first key of a brand-new tenant does. If a sponsorToken IS present, store it too: it is never recoverable and it approves grants and operates the kill switch. The gate rate-limits key issuance to 10 keys per hour per client IP.
Inputs: email (required), invite_code (required), tenant_name. Returns: result
writ_keysA
List API key metadata for the tenant (never raw keys).
Inputs: no named parameters. Returns: result
writ_leaseA
Convert an ALLOW token into a single-use gated-execution lease.
Call this AFTER writ_check returns ALLOW, passing that ALLOW's authToken. The lease is bound to the exact upstream request you intend to run: the same method, path, and body bytes you will later pass to writ_execute. A lease is single-use; once executed (or expired) it is spent.
Args: auth_token: The authToken from a writ_check ALLOW decision. system_id: The registered upstream system: "stripe", "github", or "salesforce". A vaulted credential must be active for this system or the gate answers ok:false. method: HTTP method of the upstream request (e.g. "POST"). path: Upstream path (e.g. "/v1/refunds"). Must match the system's allowed path patterns. body: Optional JSON object (at most 1 MB). Sent only when provided; if you lease a body you must execute the identical body. ttl_seconds: Optional lease TTL in seconds. The gate caps it at 90 and at the token's remaining life.
On success the gate answers 201 with leaseId, expiresAt, ttlSeconds, verb, target, purpose, and systemId. On failure it answers {"ok": false, "reason": ...} (token invalid or expired, or no active vaulted credential for the system). On ok:false do NOT execute.
Inputs: path (required), method (required), system_id (required), auth_token (required), +2 more. Returns: result
writ_manifestsA
List scanned repos and their risk profiles, or fetch one manifest.
With no repo_id, returns a table of repos with writScore, scanStatus, and riskDigest (counts per risk class). With repo_id, returns the full signed manifest for that repo.
Inputs: repo_id. Returns: result
writ_policyA
Read the tenant's verb policy: which verbs allow, deny, require a grant, or step up.
Inputs: no named parameters. Returns: result
writ_principalsB
List the tenant's principals (identity directory).
Inputs: no named parameters. Returns: result
writ_receiptsB
List recent decision receipts (audit trail). Newest first.
Inputs: limit. Returns: result
writ_reinstateA
SPONSOR ONLY. Undo writ_revoke: the principal is evaluated by policy again.
Scoped to your tenant. Requires WRIT_SPONSOR_TOKEN.
Inputs: agent_id (required), sponsor_id (required). Returns: result
writ_revokeA
SPONSOR ONLY. Kill switch: immediately deny all future checks for this principal.
Revocation overrides live grants and tenant policy. Use when a principal is compromised, misbehaving, or its task is done. Scoped to your tenant. Requires WRIT_SPONSOR_TOKEN.
Inputs: agent_id (required), sponsor_id (required). Returns: result
writ_sandboxB
Get a free 90-second sandbox grant for a demo write. No API key needed.
Issues a live grant for verb "demo_write" on a target starting with "demo-", then runs writ_check so you get back an ALLOW decision plus auth token to practice the verify-before-write flow end to end.
Inputs: target (required), purpose (required), agent_id (required), sponsor_id (required). Returns: result
writ_tenant_inviteA
Mint a team invite code (writ_inv_...) for your tenant.
Share the code with teammates: they pass it as invite_code to writ_join_tenant (POST /v1/keys) to join this tenant instead of creating their own. Creating a new code ROTATES and invalidates the old one, so there is only ever one live invite code per tenant, and only mint when the team needs a fresh code.
Returns the gate payload verbatim: inviteCode, tenantId, and a note.
Inputs: no named parameters. Returns: result
writ_tenant_notifyB
Get or update step-up notification settings.
With no arguments, returns the current settings. With arguments, updates them: step_up_email enables/disables step-up emails; step_up_webhook_url sets a generic or Slack webhook URL; use an empty string to clear.
Inputs: step_up_email, step_up_webhook_url, step_up_webhook_type. Returns: result
writ_verbsA
List the tenant's verb vocabulary, including custom verbs.
Inputs: no named parameters. Returns: result
writ_verify_receiptsA
Verify the tenant audit-log hash chain and report whether it is intact.
Walks the tenant's receipt chain from its head, recomputing every visited
receipt's HMAC. This is the endpoint behind ./writ verify-chain: use it
to prove the audit log has not been tampered with.
Args: limit: Max receipts to verify, newest first. Default 200, clamped to the range 1..1000.
Returns the gate payload verbatim: ok (chain intact), checked (receipts verified), tip and tipReceipt (chain head), chainedFrom, legacyCount, and complete. Verification stops at legacy (pre-chain) receipts and reports them as legacyCount.
Inputs: limit. Returns: result
writ_verify_tokenA
Verify a Writ auth token against the write you are about to execute.
Call this IMMEDIATELY before executing an ALLOWed write, with the exact verb/target/purpose you intend. If valid is false — expired, tampered, or bound to a different purpose — do NOT execute the write; call writ_check again.
This is the point-of-action enforcement: the check authorizes, the token proves the authorization still matches what you are actually doing.
Inputs: verb (required), target (required), purpose (required), auth_token (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 24 tools
Most tools have clearly distinct purposes within the gated-write lifecycle (check, verify_token, lease, execute, receipts, sponsor actions). A few could be confused at a glance: the receipt trio (list_receipts, verify_receipts, explain_receipt) and the verify_receipts vs verify_token pair share similar naming, though descriptions differentiate them.
All tools share a consistent 'writ_' prefix and snake_case, which is readable and predictable. However, the internal pattern mixes verb_noun (writ_check, writ_lease) with noun_verb (writ_tenant_invite, writ_github_toggle_pr_comments), so it's mostly consistent with minor deviations.
24 tools is on the heavy side of the 16-25 borderline range. While each tool maps to a real operation across multiple sub-domains (gating, receipts, tenants, badges, GitHub, sponsors), the surface feels large enough that a few could potentially be consolidated (e.g., badge mint/revoke).
The core gated-write workflow is fully covered: check -> verify_token/lease -> execute, plus receipts, audit verification, policies, sponsors, and tenant management. Minor gaps exist: policy, principals, and API keys are read-only (no update/delete), likely intentional given dashboard-managed admin, but agents cannot fully manage those resources.
Maintenance
Related MCP Connectors
Authorize AI agent tool calls before they run: policy-as-code, human approval, signed receipts.
AgentGuard — 20-tool AI safety MCP: policy preflight, risk scoring, audit logging, rate limits.
See, price, and control every tool call your AI agents make: policy checks, cost, and audit tools.
Governed access to sensitive data, secrets and APIs for AI agents. A signed proof for each decision.
Related MCP Servers
- AlicenseAqualityBmaintenanceCryptographic accountability for AI agents. Ed25519-signed receipts for every MCP tool call. Constraints, chains, AI judgment, invoicing, and local dashboard included.241MIT
- AlicenseAqualityCmaintenanceAI agent identity, permissions, trust scores, and tamper-evident audit trails. 17 MCP tools: register agents (Ed25519 keypairs), check permissions (sub-5ms), emit audit events, verify trust scores (0-100), delegate credentials, ephemeral agents. IETF Internet-Draft filed. Works with LangChain, OpenAI, CrewAI, Stripe ACP. npx @vorim/mcp-server1783 npm66MIT
- AlicenseBqualityBmaintenanceA governance proxy for AI tools — every MCP/agent tool call is policy-gated, secret-redacted, and written to a hash-chained, offline-verifiable audit trail.13MIT
- AlicenseAqualityAmaintenanceGates every AI agent tool call against your policy before it runs, then writes a hash-chained, tamper-evident record of what was decided and what happened. Anyone can verify that record offline, without your software, your systems or any key you hold.4453 PyPI15AGPL 3.0