Aperture Bot

Your agent writes the change. Aperture checks it first.

Grok Bot, Claude Code, Cursor or any MCP client can call Aperture's check_change before it applies a change. It runs the checks the editor runs on every staged change: the files parse, the imports resolve, and the TypeScript compiler finds no new errors, in the files the agent touched or the ones that use them. It also flags a change that skips or cuts short the tests. Nothing is run or kept, and it is free on every plan.

Set it up

1. Make a token
Signed in, use Connect an agent above (also in Settings → Agents), and name a token after the agent. It is shown once; Aperture keeps only a hash of it.
2. Add Aperture to the agent
The server is https://aperturesais.grok.me/api/mcp, and the token goes in an Authorization header. Put your token where <token> is:
Claude Code
```
claude mcp add --transport http aperture https://aperturesais.grok.me/api/mcp --header "Authorization: Bearer <token>"
```
Cursor (.cursor/mcp.json)
```
{
  "mcpServers": {
    "aperture": {
      "url": "https://aperturesais.grok.me/api/mcp",
      "headers": {
        "Authorization": "Bearer <token>"
      }
    }
  }
}
```
Grok Bot or any MCP client
```
Server URL: https://aperturesais.grok.me/api/mcp
Header: Authorization: Bearer <token>
```
It speaks MCP over HTTP and has been tested with the official MCP TypeScript SDK. If your agent can only add an MCP server that signs in with OAuth, open an issue and say which agent.

3. Tell the agent to use it

Put this in the task, or in the agent's standing instructions:

Instruction

Before you finish, call check_change on Aperture with the project's files and the new text of every file you changed. If a check is red, fix what it says and call check_change again until nothing is red. Then run the project's tests.

What an answer looks like

An agent asked to show prices in any currency gives formatPrice a second argument in src/price.ts. That file type-checks on its own. src/cart.ts, which the agent never opened, still calls it with one. This is the answer it gets, word for word; a test keeps this page equal to what the server says.

The change: src/price.ts

export function formatPrice(cents: number, currency: string): string {
  return new Intl.NumberFormat("en-US", { style: "currency", currency }).format(cents / 100);
}

src/cart.ts (not changed)

import { formatPrice } from "./price";

export function cartLabel(items: number, cents: number): string {
  return `${items} items · ${formatPrice(cents)}`;
}

check_change answers

Do not apply this change as it is: 1 check red on 1 changed file. Fix what it says and call check_change again.

✓ Parses: 1 file parses.
✓ Imports resolve: Every import in 1 script resolves.
✗ Types: src/cart.ts: TS2554 at line 4: Expected 2 arguments, but got 1.
    src/cart.ts: TS2554 at line 4: Expected 2 arguments, but got 1.
    src/cart.ts:
      2 | 
      3 | export function cartLabel(items: number, cents: number): string {
    > 4 |   return `${items} items · ${formatPrice(cents)}`;
      5 | }
      6 | 
– Tests: Not run: this server does not run code. Run the project's tests before you apply the change.

What it catches, and what it does not

Of the 33 bad edits in the benchmark, check_change stops 20 without running anything. The editor stops 27, because it also runs the tests in your tab: the other 7 only show up when the tests run. So keep running your tests; this catches what an agent breaks before it gets that far.

Questions

Is the code my agent sends kept?+

No. The server parses and type-checks it in memory and answers. Nothing in it is run, saved, logged, or sent to a model. The token is stored only as a hash.

Does it run my tests?+

No. Running tests means running the code, and the server never runs what an agent sends. The answer always says the tests were not run, so the agent runs them itself. The Aperture editor does run them, in your browser tab.

What does it cost?+

Nothing. No model is called, so there is nothing to bill. It is on every plan, Hobby included.

Which projects can it check?+

JavaScript and TypeScript. Imports are read from import, export … from and require() of a string; a require inside try is left alone, since a missing module there is usually on purpose. Up to 160 files and 2.5 MB per check, and 20 checks a minute per account.

How do I stop an agent using it?+

Revoke its token in Settings → Agents. The next call from that agent is refused.

To run the same checks on every pull request in a repository, there is Aperture Agent Check, with the bot or as a GitHub Action. What the server keeps and why is on the privacy and security pages.