# Perch vs Macroscope: reuse requirement checks while the agent iterates

Compare Perch’s saved requirement checks with Macroscope and choose a workflow for recurring coding-agent mistakes.

Source: https://perchscan.com/compare/perch-vs-macroscope/
Published: 2026-10-14

Perch prices rule checks by usage and makes cached checks on unchanged code free. That fits an agent workflow that checks the same requirement throughout an edit and again in CI.

## Check a saved rule on the current method

This is the same requirement and command used in the [captured refund example](/examples/plain-english-rules/):

```yaml
- name: refund-once
  where: checkout.py
  each: method
  ensure: Refunded orders cannot be refunded again.
```

The deliberately broken method calls the payment provider without checking the order status:

```python
def refund(order, payment):
    payment.refund(order.total)
    order.status = "refunded"
    return order
```

Run the focused check from the repository root:

```sh
perch check checkout.py::refund --rules refund-once --json
```

In the [September 20, 2026 capture](/demos/refund-capture.json), the unguarded refund was flagged at 80% confidence and exited 3. Adding `if order.status == "refunded": return order` before the payment call made the check pass and exit 0. The capture uses `refund.py`; use `checkout.py` when adapting the public [order-service source at commit 4af67af](https://github.com/lakeday-org/perch/blob/4af67af46d76ac99398d61c7ad0a45441760d4dc/test/fixtures/order-service/checkout.py).

Save the rule with the code, then use the same command to check the next agent edit. Add regression tests for concurrency and payment-provider idempotency in the application.


## Compare the review workflow

| Workflow | Perch | Macroscope |
| --- | --- | --- |
| Billing unit | 10¢ per 1,000 fresh rule checks, no seat fees | GitHub reviews cost 2.5–20¢ per KB by mode, with a 10 KB minimum and no seat fees |
| Unchanged checks | Cached checks are free | This page makes no claim about Macroscope cache behavior |
| Budget example | About 50¢ for a mid-sized PR of about 150 methods read | Balanced GitHub review costs 5¢/KB, with a 50¢ minimum; diff size determines the total |
| Local checks | MIT CLI; `perch check` reads uncommitted files | MIT local CLI for working-tree and branch changes |
| Custom requirements | English `ensure` rules with project, file and method selectors | Markdown agent instructions and configurable check-run agents |

## Reuse checks with free cached answers

Perch makes cached checks on unchanged requests free. Save the requirement once, run it while the agent edits, and use it again in CI. The cache also gives unchanged requests the same saved answer, so repeated checks reuse both the rule and its result.

## How Macroscope handles review

Macroscope’s current [pricing documentation](https://docs.macroscope.com/pricing) lists GitHub review modes at 2.5–20¢ per KB, each with a 10 KB minimum. Balanced costs 5¢/KB. Its CLI and agent usage instead follows model cost plus 5%; the GitHub diff rate is a separate billing surface. Macroscope has no seat fees and offers free credits.

Its [local CLI](https://docs.macroscope.com/cli) can review uncommitted and branch changes. [Check-run agents](https://www.macroscope.com/blog/introducing-check-run-agents) use Markdown instructions and configurable tools, paths and gates. The [local CLI is MIT licensed](https://github.com/prassoai/macroscope-local/blob/main/LICENSE).

Choose Perch for independently selectable behavior requirements: save an `ensure` statement, scope it to a project, file or method, and run that check after the agent edits. Unchanged requests reuse cached answers for free. Perch’s price follows fresh rule checks rather than GitHub diff kilobytes.

## Add Perch to your agent workflow

Follow the [Perch quick start](https://docs.perchscan.com/install/), then save the requirement with the code. Install the skill for the coding agent you use:

```sh
perch setup claude-code
# Or: perch setup codex
# Or: perch setup cursor
```

The Perch skill instructs the agent to check the named rule after each relevant edit, inspect the finding, repair the code, and recheck. Keep the rule and regression test beside the application so the next session can use the same requirement.

With your base reference fetched, add `perch scan --since origin/main --filter type=lint` beside your tests in CI. [CI setup](https://docs.perchscan.com/ci/) explains the changed-code scan. Gated findings exit 3; exits 1 and 2 mean the check did not complete.

## Compare cost and result limits

Perch charges 10¢ per 1,000 rule checks, with cached checks free. [The pricing comparison](/#pricing) estimates about 50¢ for a mid-sized pull request with about 150 methods read, including surrounding code. Usage follows the selected questions and their code context.

Unchanged requests reuse cached answers for free; fresh model judgments can vary. Perch’s CLI is MIT licensed. Model analysis sends relevant source to the configured service.

Competitor documentation reviewed October 14, 2026. [All comparisons](/compare/) · [Perch rule syntax](https://docs.perchscan.com/rules/)