Rams for agents.

Your agent writes the UI. Rams is the design review it calls before committing: 291 rules, a 0–100 score, and fixes it can apply.

Get a free API key How the MCP works

Setup, per platform

Fastest path — one command writes the standing instruction into AGENTS.md / CLAUDE.md and wires the MCP server into .mcp.json:

npx rams-init --key=rams_YOUR_API_KEY -y

API keys are free: 30 reviews a month, no card, full engine.

Claude Code

One command. Or install the rams plugin from the community marketplace.

claude mcp add --transport http rams https://worker.rams.ai/mcp \
  --header "Authorization: Bearer YOUR_RAMS_API_KEY"

Cursor

Add to .cursor/mcp.json (or install Rams from cursor.directory).

{
  "mcpServers": {
    "rams": {
      "url": "https://worker.rams.ai/mcp",
      "headers": { "Authorization": "Bearer YOUR_RAMS_API_KEY" }
    }
  }
}

Codex

Add to ~/.codex/config.toml.

[mcp_servers.rams]
url = "https://worker.rams.ai/mcp"
http_headers = { "Authorization" = "Bearer YOUR_RAMS_API_KEY" }

Any MCP client

Remote server, Streamable HTTP, stateless. Registry name: ai.rams/rams.

POST https://worker.rams.ai/mcp
Authorization: Bearer YOUR_RAMS_API_KEY

Make it standing policy

Add one line to the repo's AGENTS.md or CLAUDE.md and every session runs the review without being asked:

Before committing UI changes, run a Rams design review (review_files)
and fix any critical issues.

Three tools

review_files

Up to 20 UI files in; a scored review out. 0–100 with severity, category, file:line, and a concrete fix per issue — the same engine pull requests get. Any confirmed critical caps the score at 59.

verify_fixes

After your agent applies fixes, re-check the original findings against the updated files: fixed vs still-present, per finding. One scoped call, seconds not minutes — and it never consumes review quota.

usage

Remaining review quota for the workspace. Free to call.

Machine-readable summary of everything Rams does: rams.ai/llms.txt

The loop

Agents ship UI in a loop — issue, code, PR, release. Rams is the design judge inside it:

1. npx rams-init            # the standing instruction, installed
2. review_files             # 0–100 score, findings, applyable patches
3. your agent applies       # git apply, per finding
4. verify_fixes             # fixed / still-present — free, seconds

In CI, the same judge is one YAML block — score every PR, gate on criticals, or run scheduled sweeps that only read what changed:

- uses: rams-design/rams-action@v1
  with:
    api-key: ${{ secrets.RAMS_API_KEY }}
    fail-on: critical        # or score<80, or never
    # mode: since-last-run   # scheduled sweeps — findings + patches land
                             # in rams-review/ for your own agent step

Rams never dispatches your agents — it judges, your tools repair. Any agent, any orchestrator, one consistent bar.

Structured output, apply-able fixes

Every review_files result carries structuredContent alongside the prose — the same facts, machine-readable, with a declared output schema. Fan a fixer agent out per finding with a map, not a regex.

{
  "score": 74,
  "summary": "...",
  "detectedCounts": { "critical": 1, "serious": 2, "moderate": 3 },
  "issues": [{
    "severity": "critical",
    "category": "accessibility",
    "title": "Icon button has no accessible name",
    "file": "src/Toolbar.tsx",
    "line": 41,
    "fix": "<button aria-label="Search">...",
    "patch": "--- a/src/Toolbar.tsx
+++ b/src/Toolbar.tsx
@@ -41,1 +41,1 @@ ..."
  }],
  "reviewsUsed": 12,
  "reviewsLimit": 30
}

When a fix locates unambiguously in the code you sent, patch is a unified diff you can git apply directly. Ambiguous fixes stay prose-only — a wrong patch is worse than no patch.