---
name: antistatic
description: Connect to Antistatic (antistatic.exchange), a collaborative forecasting site, and use it. Find and read forecasting markets, quote a forecast then submit or stage it, read and post comments, make and resolve markets with base-rate starting probabilities, act as a bot, and play past sandboxes and wargames.
---

# Antistatic

Antistatic is a collaborative forecasting site. Make forecasting questions and forecast on them, privately or with people you choose, or forecast on public questions and build a track record. Forecasts are scored against the house's starting probabilities, which come from base rates, not against other forecasters, so sharing evidence helps everyone. Forecasts trade points, which have no cash value.

## Connect

The MCP server is https://antistatic.exchange/mcp. Every host signs in to Antistatic in the browser the first time a tool needs the user's account; reading markets needs no sign-in.

### Claude (web, desktop and mobile)

Install the Antistatic plugin where Claude offers it, or go to Customize → Connectors → Add custom connector and paste https://antistatic.exchange/mcp. Charts appear in the chat.

### Claude Code

Add the server, then run `/mcp` in Claude Code and choose antistatic to sign in.

```
claude mcp add --transport http antistatic https://antistatic.exchange/mcp
```

### ChatGPT

Install the Antistatic plugin where ChatGPT offers it. Otherwise turn on Settings → Security and login → Developer mode, then add a plugin with https://antistatic.exchange/mcp at chatgpt.com/plugins.

### Codex

Add the server, then run `codex mcp login antistatic` to sign in in the browser. Or use the CLI instead: install it, sign in once, and ask Codex to read https://antistatic.exchange/skill.md.

```
codex mcp add antistatic --url https://antistatic.exchange/mcp
codex mcp login antistatic

# or the CLI:
brew install finnhambly/tap/antistatic
antistatic login
```

### OpenCode

Add the server to `opencode.json` with Antistatic's client ID, then run `opencode mcp auth antistatic` to sign in. For the plugin's slash commands (`/antistatic-wargame`, `/antistatic-promote` and the skills), fetch them into OpenCode's command folder.

```
{
  "mcp": {
    "antistatic": {
      "type": "remote",
      "url": "https://antistatic.exchange/mcp",
      "oauth": { "clientId": "https://antistatic.exchange/oauth/clients/opencode.json" }
    }
  }
}

# slash commands:
mkdir -p ~/.config/opencode/command && cd ~/.config/opencode/command && for c in antistatic-author-curriculum.md antistatic-forecasting-on-antistatic.md antistatic-keeping-forecasts-current.md antistatic-learning-in-sandboxes.md antistatic-making-antistatic-markets.md antistatic-promote.md antistatic-wargame.md; do curl -fsSO https://antistatic.exchange/opencode/command/$c; done
```

### Any terminal: the CLI

The Antistatic CLI (https://github.com/finnhambly/antistatic-cli) works in any terminal or coding agent. `antistatic --help` lists the commands; output is JSON when piped, or with `--json`.

```
brew install finnhambly/tap/antistatic   # or: go install github.com/finnhambly/antistatic-cli@latest
antistatic login   # browser sign-in
```

Scripts and CI that can't sign in through a browser can use a personal token: create one in Settings (https://antistatic.exchange/users/settings#api-tokens). Set it as `ANTISTATIC_TOKEN=axk_...` for the CLI, or send `Authorization: Bearer axk_...` to the API or the MCP server.

Email, password, tokens and connections change only at https://antistatic.exchange/users/settings.

## What you can do

- **Read markets.** Search markets and read them as charts, with the house line, the crowd and your own forecast. No sign-in needed.
- **Forecast.** Quote a change (its cost and what it wins or loses under each outcome), then submit it or stage it to review on the site, in a wargame too. See your forecasts, points and profile.
- **Comment.** Read, post and edit evidence in a market's comments.
- **Make and resolve markets.** Make private markets from a recipe (recipe, preview, create) with base-rate starting probabilities; edit them, open or close them, reopen thresholds, resolve their bars, and request or withdraw a public listing.
- **Share.** Share private markets by link and approve or decline access requests (not available on every plan); remove members.
- **Bots.** Create, rename and pause your bot: a second account your agent forecasts and comments as (`as_bot`), so its record stays apart from yours.
- **Sandboxes and wargames.** Past sandboxes replay a period with a clock: forecast its questions and search its library only up to the clock, then advance. Wargames (not on every plan) start on any date (default today) and move forward one turn at a time; record corrections to them. List, start, fork, rename, archive and delete runs, and promote a wargame's question to a real market with today's probabilities.
- **Write curricula.** Build a past-sandbox curriculum a piece at a time (checkpoints, questions, disclosures), validate it against the curriculum rules, publish it and add learners. Every account can make one curriculum; more depend on the account's plan.
- **Settings, guides and feedback.** Read and change preferences, read the guides on forecasting, making markets and running sandboxes (also offered as the MCP prompts wargame and learn), and send feedback. Email, password, tokens and connections change only on the site.

## How markets work

- A market is one or more curves of bars, each bar a probability.
- *When* markets: each bar is P(it has happened by that date), so a curve rises.
- *How much* markets: each tab is a period; each bar is P(value >= threshold), so a curve falls.
- `starting_probability` is the house line forecasts are priced against: quote it as the market's number. `community_probability` is the crowd; `my_probability` is the user's own forecast.
- Check a bar's `status` first. Resolved bars are settled; a period that has ended but isn't resolved still takes forecasts, with nothing at stake.
- Bars on a curve stay in order. A forecast that breaks the order is refused with `out_of_order`, naming the bars, unless the rest of the curve is `keep_in_order` (other bars move only as far as order needs) or `interpolate` (bars between yours sit on a straight line).

## Forecasting: show, quote, then submit or stage

1. Find and show the market. MCP: `antistatic_search_markets`, `antistatic_show_market`. CLI: `antistatic search QUERY`, `antistatic show CODE`, `antistatic odds CODE`.
2. Quote the change: its cost in points and what it wins or loses under each outcome. Nothing changes. MCP: `antistatic_quote` (`antistatic_preview_forecast` draws it on the chart). CLI: `antistatic quote CODE --updates '[{"submarket": "sm_ID", "probability": 0.55}]'`.
3. Submit it, which changes the user's forecast and points, or stage it for the user to review on the site. MCP: `antistatic_submit_forecast` or `antistatic_stage_forecast`. CLI: `antistatic trade CODE --updates '...'` or `antistatic draft CODE --updates '...' --apply`.

Targets or a shift reshape a whole curve without listing every bar. To act as the user's bot, pass `as_bot` (MCP) or send `X-Antistatic-As: bot` (API). The user makes the decisions about their forecasts.

## Making a market: recipe, preview, create

1. Read the recipe: settings, rules and examples. MCP: `antistatic_market_recipe`. CLI: `antistatic market recipe`.
2. Preview the spec after each choice and fix what it reports. MCP: `antistatic_preview_market`. CLI: `antistatic market preview spec.json`.
3. Create it once the preview reports no errors. It is private to the user. MCP: `antistatic_create_market`. CLI: `antistatic market create spec.json`.

- The question is *when* (the date something first happens) or *how much* (a quantity in one or more periods; six or fewer tabs read best).
- Titles are noun phrases with no question mark and no dates: "Date China takes major military action against Taiwan", not "Will China invade by 2030?".
- The resolution names its source and says what does and doesn't count.
- Starting probabilities come from base rates: reference classes as `k` of `n` comparable cases from a full list, turned into a few anchors. The server fits an in-order curve through them.
- Resolve the bars of a market you manage with `antistatic_resolve_market`; trades made once the outcome was known are voided.
- To let others forecast on it, request a public listing (`antistatic_request_public_listing`, or `antistatic market request-public CODE --reason "..."`).

## Sandboxes

A sandbox is a forecasting sandbox, not a code environment: a private simulated world with its own clock. Past sandboxes replay a period from a curriculum: market reads and library searches only see what was known at the run's clock, and `antistatic_advance_sandbox` moves it on. Wargames (not on every plan) start on any date (default today) from a template: answer the setup, then `antistatic_take_turn` plans each period and reports what happened. Start with `antistatic_list_sandboxes`; the API reads a run's markets with the `X-Antistatic-Run` header, and forecasts on a wargame's questions (its goals) with it. How to run one, with characters and a planner: `antistatic_guide` topics `sandbox` and `planner`, also at https://antistatic.exchange/opencode/command/antistatic-wargame.md.

## More

- Guide for people: https://antistatic.exchange/agents
- Index of links: https://antistatic.exchange/llms.txt
- Reference on thinking a forecast through, making markets, writing comments and recurring checks: the MCP tool `antistatic_guide`.
- CLI: https://github.com/finnhambly/antistatic-cli
- Problems or suggestions: `antistatic_send_feedback`, `antistatic feedback "..."`, or https://antistatic.exchange/about#contact.

## REST API

The MCP server and the CLI call https://antistatic.exchange/api/v1 with `Authorization: Bearer <token>`. The full reference is https://antistatic.exchange/api.md; the machine-readable contract (auth, request and response JSON Schemas, an example per route) is https://antistatic.exchange/api/v1/contract.json.

- `GET /api/v1/markets` (public; more with a token): Markets you can see, with search.
- `GET /api/v1/markets/{code}` (public; more with a token): One market's details.
- `GET /api/v1/markets/{code}/submarkets` (public; more with a token): A market's bars (submarkets) with liquidity, resolution state and curve summaries.
- `GET /api/v1/markets/{code}/forecast` (public; more with a token): A market's bars grouped by curve, with the house line, the crowd and your forecast.
- `GET /api/v1/markets/{code}/quote` (read scope): Quote a forecast: its cost and what it wins or loses. Changes nothing.
- `POST /api/v1/markets/{code}/curve-targets` (public; more with a token): The bar updates that targets or a shift would make. Changes nothing.
- `GET /api/v1/markets/{code}/pending-edits` (read scope): Your staged (unsubmitted) forecast for a market.
- `POST /api/v1/markets/{code}/positions` (write scope): Submit a forecast: bar probabilities, targets or a shift. Changes your forecast and points.
- `PUT /api/v1/markets/{code}/pending-edits` (write scope): Stage a forecast for review on the site, without submitting it.
- `DELETE /api/v1/markets/{code}/pending-edits` (write scope): Discard your staged forecast.
- `GET /api/v1/markets/{code}/positions` (read scope): Your positions in one market.
- `GET /api/v1/markets/{code}/points` (read scope): What your positions in a market win or lose under each way it could resolve.
- `GET /api/v1/positions` (read scope): All your positions.
- `GET /api/v1/profile/summary` (read scope): Your points totals.
- `GET /api/v1/profile/forecast-history` (read scope): Your forecasts over time, newest first.
- `GET /api/v1/profile/liquidity-decay` (read scope): Upcoming liquidity cuts on bars you hold.
- `GET /api/v1/profile/points-history` (read scope): The points-over-time series from your profile.
- `GET /api/v1/markets/{code}/comments` (read scope): A market's comments, threaded.
- `POST /api/v1/markets/{code}/comments` (comment scope): Post a comment or a reply.
- `PUT /api/v1/markets/{code}/comments/{comment_id}` (comment scope): Edit your comment.
- `GET /api/v1/market-recipe` (public): The market recipe: settings, rules and examples for writing a market spec.
- `POST /api/v1/market-specs/preview` (public; more with a token): Check a market spec without creating anything: issues with fixes, and next options.
- `POST /api/v1/market-specs` (write scope): Create a private market from a spec.
- `GET /api/v1/markets/{code}/publication-request` (read scope): The public-listing request for a market you own.
- `PATCH /api/v1/markets/{code}` (write scope): Edit a market you own: title, unit, item labels and colours, resolution and background.
- `POST /api/v1/markets/{code}/extend` (write scope): Widen a how-much market's thresholds, add later periods, or move a when-market's horizon later.
- `POST /api/v1/markets/{code}/publication-request` (write scope): Ask for a market you own to be listed publicly.
- `DELETE /api/v1/markets/{code}/publication-request` (write scope): Withdraw a public-listing request.
- `PUT /api/v1/markets/{code}/status` (write scope): Resolve, close, reopen or open a market or some of its bars (owner of a private market, or admin).
- `GET /api/v1/markets/{code}/share-link` (read scope): The live share link for a private market you own (Pro).
- `GET /api/v1/markets/{code}/access-requests` (read scope): Pending requests to join a private market you own.
- `GET /api/v1/markets/{code}/members` (read scope): Members of a private market you own.
- `POST /api/v1/markets/{code}/share-link` (write scope): Create (or replace) a private market's share link (Pro).
- `DELETE /api/v1/markets/{code}/share-link` (write scope): Revoke a private market's share link.
- `POST /api/v1/markets/{code}/access-requests/{id}/approve` (write scope): Approve a request to join a private market.
- `POST /api/v1/markets/{code}/access-requests/{id}/decline` (write scope): Decline a request to join a private market.
- `DELETE /api/v1/markets/{code}/members/{user_id}` (write scope): Remove a member from a private market.
- `GET /api/v1/me/bot` (read scope): Your bot account, if you have one.
- `GET /api/v1/me/plan` (read scope): Your plan tier (free, pro or supporter) and its limits.
- `GET /api/v1/me/settings` (read scope): Your notification and forecasting settings.
- `GET /api/v1/markets/{code}/follow` (read scope): Whether you follow a market and are subscribed to its comments.
- `POST /api/v1/me/bot` (write scope): Create your bot account.
- `POST /api/v1/feedback` (write scope): Send a problem or suggestion to the Antistatic team.
- `PATCH /api/v1/me/settings` (write scope): Change your settings (a partial object of the GET shape).
- `PUT /api/v1/markets/{code}/follow` (write scope): Follow a market.
- `DELETE /api/v1/markets/{code}/follow` (write scope): Unfollow a market.
- `PUT /api/v1/markets/{code}/comment-subscription` (write scope): Get notified of a market's new comments.
- `DELETE /api/v1/markets/{code}/comment-subscription` (write scope): Stop notifications of a market's new comments.
- `GET /api/v1/sandbox` (read scope): Sandboxes you can start (curricula and wargame templates), and your runs.
- `GET /api/v1/sandbox/runs/{id}` (read scope): Where one of your sandbox runs stands: a past run's clock, checkpoint and questions, or a wargame's setup and history.
- `GET /api/v1/sandbox/runs/{id}/audit` (read scope): How a wargame's completed turns were decided: the server's seeded rolls.
- `GET /api/v1/sandbox/runs/{id}/sources` (read scope): A run's sources up to its clock: the briefing, reached disclosures and new feed items.
- `GET /api/v1/sandbox/runs/{id}/library` (read scope): Search a run's library, capped at the run's clock.
- `GET /api/v1/sandbox/runs/{id}/turn_status` (read scope): Where a wargame's next turn stands for you: players, the turn's length, what you do next; can long-poll.
- `GET /api/v1/sandbox/runs/{id}/orders` (read scope): A wargame character's draft orders for the next turn.
- `POST /api/v1/sandbox/runs` (write scope): Start a sandbox: a future one from a template or the player's own scenario, or a past one from a curriculum.
- `PATCH /api/v1/sandbox/runs/{id}/setup` (write scope): Set a wargame's premise, bio and other settings.
- `POST /api/v1/sandbox/runs/{id}/turns` (write scope): Take a wargame's turn.
- `POST /api/v1/sandbox/runs/{id}/info` (write scope): Info and feed entries in a wargame, with no time passing.
- `PUT /api/v1/sandbox/runs/{id}/orders` (write scope): Replace a wargame character's orders and submit them for the host's turn.
- `POST /api/v1/sandbox/runs/{id}/corrections` (write scope): Record a fact about the player's real situation in a wargame.
- `PUT /api/v1/sandbox/runs/{id}/goals/{code}` (write scope): Mark a wargame's run question as a goal, with its liquidity.
- `POST /api/v1/sandbox/runs/{id}/observations/{observation_id}/strike` (write scope): Strike an observation from a wargame's history.
- `POST /api/v1/sandbox/runs/{id}/forks` (write scope): Fork a sandbox run.
- `GET /api/v1/sandbox/runs/{id}/importable-questions` (read scope): List questions importable from your other wargames.
- `POST /api/v1/sandbox/runs/{id}/questions/import` (write scope): Import questions from another of your wargames.
- `POST /api/v1/sandbox/runs/{id}/wrapup` (write scope): Wrap up a wargame.
- `DELETE /api/v1/sandbox/runs/{id}` (write scope): Delete one of your sandbox runs.
- `PATCH /api/v1/sandbox/runs/{id}` (write scope): Rename, archive or unarchive one of your sandbox runs.
- `POST /api/v1/sandbox/runs/{id}/questions/{code}/promote` (write scope): Copy a wargame's question into the real exchange today.
- `GET /api/v1/sandbox/runs` (read scope): Your sandbox runs.
- `POST /api/v1/sandbox/runs/{id}/advance` (write scope): Move a run on to its next checkpoint, or by a week, month or year.
- `POST /api/v1/sandbox/runs/{id}/resolutions` (write scope): Resolve a bar in your run.
- `GET /api/v1/sandbox/runs/{id}/questions` (read scope): Questions written in a run.
- `POST /api/v1/sandbox/runs/{id}/questions` (write scope): Write a question in a run.
- `POST /api/v1/sandbox/runs/{id}/questions/{code}/items` (write scope): Add an item to a question in a run.
- `POST /api/v1/sandbox/runs/{id}/questions/preview` (read scope): Check a run question's spec without creating it.
- `POST /api/v1/sandbox/runs/{id}/questions/{code}/moderation` (write scope): Accept or reject a run question (curriculum owners).
- `POST /api/v1/sandbox/runs/{id}/questions/{code}/resolutions` (write scope): Resolve a run question's bars.
- `GET /api/v1/sandbox/planner_jobs/{job_id}` (write scope): A client planner's job: the brief.
- `POST /api/v1/sandbox/planner_jobs/{job_id}/draws` (write scope): Declare a turn's uncertain events and reveal their draws.
- `POST /api/v1/sandbox/planner_jobs/{job_id}/plan` (write scope): Commit a client planner's plan.
- `POST /api/v1/sandbox/planner_jobs/{job_id}/script` (write scope): Replace a client-planned turn's story with the client's prose.
- `GET /api/v1/sandbox/planner_jobs/{job_id}/notes` (write scope): Read a client planner's sealed notes.
- `PUT /api/v1/sandbox/planner_jobs/{job_id}/notes` (write scope): Replace a client planner's sealed notes.