# Pre-action `/review` for capital-moving agents

Use this when an agent already has a signal and is about to call `trade()`.

Do Not Act is the narrow gate between signal and execution:

```text
market_id + side + requested_notional + slippage_policy
  -> READY | CAUTION | DO_NOT_ACT | INSUFFICIENT_EVIDENCE
  -> reasons + safe_operating_limits + evidence timestamps + receipt
```

The point is not to replace your strategy. The point is to make the final action admissible at the current venue state, public-book capacity and resolution lifecycle.

## Minimal `/review` contract

Your bot can expose an internal function like this:

```python
def review_before_trade(market_id, side, notional_usd):
    diagnostic = donotact_guard(
        market_id,
        side=side,
        notional_usd=notional_usd,
        max_slippage_bps=200,
        policy="conservative",
    )
    if diagnostic["decision"] == "CAUTION":
        return local_policy_branch(diagnostic)
    return diagnostic
```

`DO_NOT_ACT` and `INSUFFICIENT_EVIDENCE` should block unattended execution. `CAUTION` should require an explicit local policy branch. `READY` only means the diagnostic gate did not find a blocking condition under the submitted context.

## What the gate checks

- current and historical dispute lifecycle;
- resolution ambiguity and evidence gaps;
- public orderbook spread, depth and staleness;
- requested size against conservative public-book capacity;
- max slippage policy;
- source timestamps and response freshness;
- machine-readable reasons your bot can log.

## Try it with the public proof-set

```bash
curl -fsS "https://donotact.com/v1/preflight/polymarket/580810?intent=enter&side=buy_yes&notional_usd=25&max_slippage_bps=200&policy=conservative" \
  -H "X-API-Key: demo"
```

Expected behavior on this proof-set market: the response should block because the UMA lifecycle contains disputed history.

## For fast markets and capital recycling

If your bot recycles capital across 5-minute or 15-minute markets, call the gate before each new leg, closeout attempt, or capital-release action. The question is not only whether the signal still looks good. The question is whether the next action is admissible at the requested size.

Use the submitted `notional_usd` and `max_slippage_bps` as hard policy inputs:

- lower size when public depth cannot absorb the action;
- wait when the book is stale or one-sided;
- block when dispute, ambiguity or capacity checks fail closed;
- log the signed receipt so the skipped action is auditable later.

This keeps the strategy free to find opportunities while the execution path gets one deterministic stop/go branch before capital moves.

## Latency

For copy-trading, capital release and 5-minute/15-minute markets, the normal
path is an inline HTTP gate immediately before the order path. For tighter
market-making loops, keep verdict snapshots warm through watchlists/WebSocket
streams and let the order path read the latest local snapshot.

Current measured profile and timeout guidance: `/docs/latency`.

## Move from demo to your bot

If this page matches a live-execution path in your bot, do the next step now:

- [Copy the Python guard](/go/docs-pretrade-copy-guard) and place it immediately before `trade()`.
- [Create a free key](/go/docs-start) for your own markets after the proof-set call works.
- [Send your repo or planned trade flow](/go/docs-integration-help) for a placement review.
- [Use Builder access](/go/docs-pricing) for watchlists, webhooks, live streams, CSV exports, receipts and higher quota.
- [Use x402](/go/docs-x402) if an agent should pay per call without account state.

The first integration should be boring: call the gate, continue only on `READY`, and log everything else.

## Boundary

Do Not Act does not execute trades, hold funds, sign orders, custody wallets, route orders, or promise outcomes. It supplies the pre-action stop/go contract your own bot can enforce before it moves capital.