electionsmcp.com

Turn a place name or shorthand into its canonical geo_id — resolve natural-language or structured location input.

WHO holds or runs for WHAT — turn a candidate/officeholder name into their seat + next race.

BROWSE the canonical candidate registry WITHOUT a name — the nameless companion to resolve_candidate (which requires a name).

ADDRESS → EVERY district + EVERY race you run there.

Boundary reference, children, and a demographic summary (county grain — ACS 2023; states and districts return boundary + identity only) for a canonical geo_id (us, us-ca, us-ca-cd-03, us-ca-county-06017, us-ca-vtd-<id>).

What contests are on the 2028 Pennsylvania ballot — the real races (president, senate, house, governor, state legislature) for any state and cycle.

THE PLANNER'S CALENDAR — what is on the ballot when.

When is the New Hampshire primary?

New Hampshire moves its primary to June, starting 2028, per <source> — amend the canonical election-date object.

Set a candidate's vote share, such as the Democratic candidate to 54%, in one specific county, district, state, or precinct (the general-election override).

How many votes a candidate needs to win a contest — the win number and remaining gap.

Return the STRUCTURED precinct data an orchestrator needs to reason about where to focus — baseline share, modeled share, turnout, ballots, gap-to-goal, demographics where available.

Instantiate a tenant workspace (a Race) on a real-world Contest.

Delete a Race (workspace-scoped).

List the Races (contest workspaces) in this workspace, with scenario counts.

One Race with its contest, scenario list, and latest top-line per scenario.

Create a new Scenario (a modeled path) — optionally inside a Race and seeded from a contest_id or an existing scenario (import_from).

See what the app RENDERS — the view-model the front end draws, without a browser (tk_0b6d3501).

Fly the LIVE map camera to a geography — frame the state / county / district / precinct the viewer is watching, so "show them the decisive counties" actually moves the view (tk_9e8de8).

A headless server-rendered IMAGE of the map — the rendered view a viewer sees, as SVG or PNG, WITHOUT a browser (tk_0b6d3501 P2).

A headless server-rendered IMAGE of a DATA-BOUND chart/scorecard for a scenario — the standalone counterpart to render_view (which renders maps).

AGENT PRESENTATION TOOLKIT (APT) — the discoverable WIDGET CATALOG.

APT — one widget from the catalog with its full detail: the widget record (id, name, category, tool, render_kind, surfaces, sizes, modes_allowed, status) PLUS the underlying render tool's complete inputSchema (render_view or render_chart) and a set of example params.

APT — the ONE call that mints a slide-ready visual at the right pixel size.

APT — the discoverable PRESENTATION TEMPLATE CATALOG: opinionated deck blueprints an agent can build.

APT — one presentation template with its full slot schema.

APT — build a first-class, durable DECK: an ordered set of narrative slides that can span ONE or MANY simulations (unlike compose_dashboard, which is a war-room grid, or generate_report, which is a longform article).

APT — the ONE call that mints EVERY visual a presentation template needs, at deck pixel sizes, into a single asset MANIFEST.

APT — read one durable deck by id: the full agent-readable JSON (all slides with their titles, layouts, widget refs and rendered assets, thesis/methodology, per-sim version_hashes and the deck version_hash).

APT — edit ONE slide of a durable deck.

APT — list the durable decks in this workspace (id, name, template, simulation_ids, brand_kit_id, version_hash, updated_at), most-recently-updated first.

APT — delete a durable deck by id (workspace-scoped).

APT — per-slide SPEAKER NOTES assembled DETERMINISTICALLY from the real model numbers (NOT invented prose — there is no app-side LLM).

APT / brand kit — create a workspace BRAND KIT so reports, charts, decks and exports can be published under a user's own identity (logo, color palette, typography, disclaimer/footer) rather than Elections MCP defaults.

APT / brand kit — list this workspace's brand kits (most recent first).

APT / brand kit — read one brand kit by id (workspace-scoped): its colors, fonts, logo, disclaimer and footer tokens.

APT / brand kit — delete one brand kit by id (workspace-scoped).

APT / brand kit — PAINT a workspace brand kit (logo, colors, fonts, disclaimer, footer) across presentation surfaces in one call.

APT — the mode-aware TRUST GATE for a deck before it ships: catch a general-election claim smuggled into a primary deck (and every other mode/anchor defect) BEFORE export_deck / build_presentation renders it.

Pre-publish QA / lint gate for a REPORT or forecast page — the report-side analogue of validate_presentation (tk_b017c462ae3f96).

APT — after compose_deck, EXPORT a durable deck to the formats humans ship: a JSON manifest, a self-contained HTML present page, a 16:9 PDF, and an EDITABLE PPTX.

APT — the ONE-SHOT PRESENTATION ORCHESTRATOR: "build me the 2028 cycle briefing" → the whole pipeline runs in ONE call.

Turn an EXISTING generated report for a scenario into CMS-ready publishing fields for WordPress, Substack, or any platform.

WRITE the view — the MCP-writable half of get_view (tk_0b6d3501 P3).

A Scenario at its latest version (or a specified version_id): metadata (incl.

Edit a Scenario's name / description / tags.

Rename a simulation/scenario — give the map a real title instead of the stuck default.

Save the scenario's current state as a new immutable, hash-stamped version in the append-only chain.

The append-only version chain for a scenario, newest last, with per-version summary + top_line.

List saved scenarios/simulations in this workspace, newest first, with scenario columns: scenario_id, name, level, cycle, contest_id, race_id, tags, durable_id, published, timestamps.

Structured diff between two versions of one scenario: which feature/precinct overrides changed (before/after) and how the top_line moved.

Revision ladder L2 as DATA (not a render): render-ready before/after delta so the CLIENT visualizes it.

Set the scenario's working state back to a prior version's payload, and return that complete per-precinct `state` (so the map redraws to the exact configuration) plus the hash chain.

Host a SELF-CONTAINED HTML report at a public /r/<token> URL.

Permanently pull a hosted HTML report you published — /r/<token> immediately begins returning 404.

List the HTML reports THIS workspace has published (newest first): token, title, byte_size, created_by, created_at, expires_at, revoked, and the /r/<token> url for each.

(RETIRED, 2026-06) The Maine 2026 primary live-results feature has been retired — the event has passed and the live feed never reached results.

(RETIRED, 2026-06) The Maine 2026 primary live map has been retired along with maine_live_results (event passed; live feed never reached results).

CAMPAIGN HQ — the one read path for governed campaign metrics (the semantic layer behind Claude-composed dashboards).

CAMPAIGN HQ — save a dashboard card: a query_metric spec + a viz spec.

CAMPAIGN HQ — create or update a dashboard: a named, workspace-scoped layout of saved cards.

CAMPAIGN HQ — fetch a dashboard with each card's query RESOLVED live (server runs query_metric per card).

CAMPAIGN HQ — list the workspace's saved dashboards (id, name, scope, updated_at).

CAMPAIGN HQ (EM-150) — delete a saved dashboard in your workspace.

SHAPE LIBRARY — pull our boundary shapes for ANY area and get a map ready to drop into a client report.

BILLING — your subscription state: {billing_enabled, logged_in, plan (personal|team|null), status, active, renews, can_save}.

WHO AM I — how THIS session is authenticated to electionsmcp, so a client (or a user checking their Connected Apps) can verify the connection.

BILLING — begin a paid subscription.

BILLING — returns {portal_url} to the Stripe Customer Portal, where the USER can update payment, switch plan, or cancel (opened in a browser).

OBSERVED POLL GEOGRAPHY (tk_ac94c24bba2379) — attach a survey's geographic crosstab LABELS ("North Jersey", "Philadelphia DMA", "Swing CDs") to real county memberships, so the observed cells can paint the map.

JOURNALIST ACCESS — self-serve, machine-checkable, free: your signed-in account email must be at your outlet's domain (the magic-link mailbox IS the domain proof — personal mail providers are ineligible), and byline_url must be a live page ON that domain carrying your byline name.

CUSTOMER SETUP — mint a short-lived (15 min), ONE-TIME connection challenge for a setup session you own.

CUSTOMER SETUP — confirm a connection challenge THROUGH the MCP pipe: proves this key reaches this account (and workspace, when bound), records the client family, and advances the setup to activate.

CUSTOMER SETUP — run (or RESUME) the checkpointed provisioning saga for a setup session you own: exactly one workspace with its client type, owner membership, roster record and the exact versioned map binding; returns per-step state and the derived next_url.

CUSTOMER SETUP — the per-step provisioning state for a setup session you own: queued/running/done/failed with the exact failed step and a safe retry (provision_customer resumes; done steps never repeat).

CUSTOMER SETUP — create a durable server-side setup session from an acquisition choice: client_type (team size/use) plus setup_scope (race|county|district|state|multi), optional geography (state/county_fips/party), and an optional FULL RACE pick (office plus district GEOID for districted offices).

CUSTOMER SETUP — the authoritative state of a setup session after auth, checkout or reload: status, step, client type, setup_scope, geography, owner linkage.

OPERATOR ONLY — create the Stripe products + monthly prices for every active client type straight from client_type_config (metadata client_type=<key>), idempotently: types whose product already exists are skipped, never duplicated.

COMMERCIAL CATALOG — the server-owned plan catalog every surface consumes (/pricing, /get-started, account billing, provisioning): seven client types with label, audience, offer (Stripe live price when the store is open, configured initial offer otherwise), seats, template, map-binding kind, and entitlements; plus the acquisition-path aliases (issues/evidence/platform require an explicit plan choice — never silently reclassified).

DEMOGRAPHIC SPINE — map MANY raw labels at once (map-or-create each), for clearing the unmapped queue at scale.

MEASURE SPINE (EM-109) — list the canonical poll metrics (the WHAT-is-measured registry): dem_ballot, gop_ballot, dem_margin, generic-ballot, trump_net_fav, wrong_track/right_track, approval, etc.

MEASURE SPINE (EM-109) — trend a canonical metric across polls/waves: joins every (poll,question,option) you mapped to the metric_key and returns the value per poll (with date, state, sample size), plus COMPARABILITY flags (never silently pools generic-vs-named ballots or pre-vs-retro results).

DEMOGRAPHIC SPINE (EM-106) — the CROSS-POLL JOIN.

DEMOGRAPHIC SPINE (EM-106) — RECALL.

AI-NATIVE MEMORY — load a place's full state-of-play in ONE call: baseline (real returns or presidential proxy), your stored poll timeline for the place, your data overlays (datasets + collections), the campaign plan, and insights — every section provenance-stamped (source + as_of).

MAP THEMES — the audience-preset registry (tk_bb87df86fdbc28): every theme with its semantic color tokens (party safe/likely/lean steps, tossup, missing, independent, selection, canvas).

List the legislative levels available to simulate.

List the geographic features (counties, states, districts, etc.) for a given level.

List candidates currently configured for a simulation+level.

Add a candidate to the candidates list for a simulation+level.

Override the vote percentages on a single feature.

Replace the entire candidate roster for a simulation+level in one call (add / edit / remove / reorder).

Remove one candidate from a simulation+level roster (and drop them from any feature overrides).

BALLOT DESIGN — record each candidate's printed ballot POSITION (and an optional per-candidate confusion/roll-off assumption) for a simulation+level roster, so same-name and crowded races can be disambiguated.

BALLOT DESIGN — read back the ballot order recorded by set_ballot_order for a simulation+level: every roster candidate with its printed ballot position (candidates with a position first, in ballot order, then any unpositioned) and any confusion/roll-off assumption.

Create a CUSTOM (write-in) candidate who is NOT in the canonical candidate registry, and persist it to the workspace so it is reusable across ALL of the workspace's forecasts (distinct DB structure from the baked registry).

List the workspace's custom (write-in) candidates created via create_custom_candidate — the non-canonical field, distinct from the baked candidate registry.

Clear the manual percentage override on a single feature (county/state/district), reverting it to its baseline.

Clear all manual overrides — the "reset to baseline" action.

Set the election cycle the simulation models (2024 actuals, or the 2026/2028/2030 races you model).

Set the presidential modeling mode: general election, or the 2028 Democratic / Republican primary.

Set the turnout (mobilization) model.

Set (or read) this scenario's ELECTION-ENVIRONMENT ballots baseline (EM-016) — YOUR assumption about the electorate's size, not a turnout prediction.

COATTAILS (EM-011): link the top of the ticket to the races below it.

MESSAGE SALIENCE + contrast/attack effect (EM-026): model WHICH message moves WHICH cohort, on top of the message-agnostic persuasion swing.

ROLL-OFF (EM-013): how many top-of-ticket voters skip a down-ballot office — office general ballots ÷ presidential general ballots over the IDENTICAL precinct set (joined on the shared precinct key, intersection only), derived from the ingested certified returns.

THE WHOLE BALLOT in one call (EM-014): every ingested office on a state's general ballot (president → state-leg), aligned per precinct over the shared precinct keys, with per-precinct SPLIT-TICKET deltas (each office's certified two-party margin minus the top of the ticket's, + = ran more D), a split_ticket_index (mean |delta| — the EM-012 split-ticket score, filterable via min_split_index to find high- vs low-split cohorts), and CROSS-PRESSURE flags where the top-line and down-ballot lean diverge beyond the threshold or elect different parties — exactly where ticket strategy lives.

Persist the swing-slider state so a scenario built by hand in the browser (uniform + demographic share swings, the swing target, and the demographic region scope) survives reload.

Pin a note or highlight on the map — an annotation that travels with the scenario, so collaborators see what the scenario is targeting at a glance.

List every annotation (pins, highlights, notes) on a scenario.

Remove a single annotation by its id.

Remove all annotations from a scenario, or only those of one type when "type" is given.

Leave a Google-Docs-style COMMENT on the scenario map — a threaded, resolvable discussion anchored to a place.

List one campaign's map comments on a scenario (oldest-first), each with its campaign_id, anchor, author, body, @mentions, parent_id, and resolved state.

The War Room as ONE campaign-scoped feed of THREADS — full discussion context in a single call.

Mark a map comment resolved (closed), like resolving a Google-Docs comment — or reopen it with resolved:false.

Toggle an emoji reaction on a War Room chat message (map comment): adds the caller to reactions[emoji] if absent, removes them if present.

Delete a map comment by id (soft-delete, so threads stay intact).

TEAM/CAMPAIGN DASHBOARD feed — map comments, discussion, and notes across the active workspace.

File a bug report, data issue, feature request, or question with the electionsmcp team.

EM-053 — file a bug / data error / feature request / question from the workflow where you hit it; returns a durable tracking id you can read back with list_tickets / get_ticket (this is the alias name for submit_ticket — same queue, same verified-key requirement).

List the tickets you have submitted (scoped to your verified key / account), newest first by default, with their current status — now with WORKING filters: status (single, comma-joined, or array — e.g.

Get one of your tickets by id: the ticket (status, body, the team's response) PLUS its full follow-up thread — comments[] in chronological order (comment_on_ticket appends; respond_to_ticket archives every prior response here as kind:resolution) and links{outgoing, incoming} (typed relations from link_tickets / submit_ticket follow_up_to, each labeled with the other ticket's title/status).

Respond to one of your tickets and set its status — the submitter-side close-the-loop tool.

TICKETING V2 — append a follow-up COMMENT to one of your tickets (same visibility rule as get_ticket: only tickets you submitted).

TICKETING V2 — create a TYPED link from one ticket to another: duplicate_of (this ticket duplicates the target), follow_up_to (this follows up on the target — the regression/bounce-back signal), blocks, implements, supersedes, relates_to.

TICKETING V2 — the GLOBAL "how does the app need to improve" view, aggregated live from the WHOLE ticket ledger (every submitter: the founder, clients, the Expressibility/Implementation loops): by_status / by_type / by_division counts, open_age_buckets (≤7d / ≤30d / older), filed_last_7d vs resolved_last_7d (velocity), open_followup_count + examples (open follow-ups filed against already-resolved work — regressions and bounce-backs), top_duplicate_clusters, most_linked_tickets, and hot_areas (most-frequent title keywords among OPEN tickets).

Apply a uniform swing in points toward one candidate across every feature in a level.

TIME-DECAYING SHIFT — the timeline-scrub primitive.

Compute the current per-candidate tally for a simulation+level.

Start a brand-new what-if model: an empty simulation of any race, ready for candidates, swings, and turnout.

List saved simulations in this workspace (id, name, level, cycle, mode, contest_id, last-modified; rows stamped with an identity also carry created_by/updated_by member user_ids).

Fetch the full state of a simulation: candidates per level, overrides per level, last modified.

Show the agent the campaign the user has OPEN right now, as one editable packet.

BIND this agent session to the USER'S OPEN /sim — the session-bootstrap contract (tk_2ba54e8466bc19 / tk_7069d33b0c682e).

HEARTBEAT — announce that this session (a browser tab or an MCP agent) is live in the workspace, optionally on one scenario.

WHO IS LIVE in this workspace right now — every browser tab and MCP agent with a presence heartbeat in the last ~45s, one row per actor: {actor, name, color, scenario_id (the sim they have open / are bound to), level, state_fips, focus_geo_id, last_seen, is_agent, is_you}.

Permanently delete a simulation.

Apply a demographic swing to the geographies matching a cohort — for ANY race level.

List features whose winner under the simulated overrides differs from the baseline — `count` is the FULL flip total; `flipped` returns up to `limit` rows (default 100).

Compare two simulations side by side — a per-feature diff at a level.

Duplicate a simulation under a new name.

List a simulation's SIBLING branches — every fork/clone that shares the same parent.

Render a shareable HTML report of the simulation across one or more levels.

List the reports generated in this workspace (newest first): report_id, title, simulation_id, created_at, url.

Delete a generated report (workspace-scoped).

Read a published report back over the protocol: returns the stored report BODY (the composed HTML generate_report rendered) plus its published metadata — published status, public URL, PDF URL, created_at — and, for the report's scenario, any public share/forecast tokens (each with its /f/ or /share/ URL).

DOCUMENT COMPOSITION — assemble an ORDERED list of heterogeneous blocks into ONE hosted long-form report at /reports/<id>.

Read a composed report's durable SPEC back (the ordered block list) — the reload path for compose_report.

List the composed reports in this workspace (newest first): report_id, title, block_count, version_hash, timestamps, url.

Mint a public read-only share token for a simulation.

Revoke a previously-minted public share token.

Nation-wide election impact across ALL 6 legislative levels in one call.

List precincts in a state with 2024 D/R/total votes baked in.

Get a single precinct by external_id (e.g.

Query precincts with structured filters, sorted + trimmed server-side.

BULK EXPORT — get a whole state's (or several states', or the national) precinct atoms as ONE downloadable file (csv | json | ndjson) instead of paginating one row at a time.

Server-side roll-up of precinct atoms — grouped sums + the grand total in ONE call, so you never pull thousands of precincts and fold them client-side.

Price a vote goal in dollars by channel — $ per net vote (a net vote = +1 to your margin) as a RANGE, not a false-precision point.

Set a precinct-level override in a simulation.

Remove a precinct-level override from a simulation, reverting that precinct to its 2024 baseline.

List every precinct override stored in a simulation.

List every district at a given race level.

Return precincts whose centroid falls inside the given district boundary.

Roll up precincts to a race outcome under the current simulation.

Apply a uniform swing to every precinct matching a filter, in one call.

Roll up every race in scope at a single level for a state, in one call.

Every manual edit in a scenario — the human's (or an agent's) overrides — in one scenario-scoped read, so a connected AI can see exactly what has been modeled and the deltas it produced.

One consolidated, machine-readable audit + handoff packet for a scenario, so a teammate or a future AI session can resume without reconstructing context from many calls.

DATA-ONLY narrative package for a presidential-primary scenario — the STORY of the race as structured data an AI client turns into its own storyboard, press piece, memo, or social thread (electionsmcp returns the numbers/structure; the client renders).

Compute Senate control for a cycle using the real class calendar.

Senate path-to-majority solver: given a cycle and a target party, it computes the MINIMAL set of up-for-grabs seats that party must win to reach control — respecting the real class calendar (only ~34 seats up, the rest carry over), the carryover baseline, and the VP tiebreak.

A race-ratings board (Cook/270towin style).

Chamber-control triage from the 2024 baseline: orders every race from most-Democratic to most-Republican, runs the cumulative count to the majority line (270 EV for president, 51 seats for senate incl.

Exposure / sensitivity sweep: applies a uniform national swing across a race set and reports how control responds — the wave size that flips the chamber each way (flip_control_at), each seat's swing-to-flip (how exposed it is), and the seat curve across swings.

Data-driven map: rank geographies by a variable, COLOR them by one variable and (optionally) EXTRUDE their HEIGHT by a second, then repaint the wall.

PORTAL — one candidate/official's standing across every race you model them in.

PORTFOLIO — every candidate or elected official you are modeling, unioned across ALL of your simulations and every level, deduped by name+party.

RACE BRIEF — one contest's whole situation in a single structured object the client AI renders: the seat, its incumbent, the candidate field, the certified-2024 rating, poll availability + the latest quality-weighted poll, Senate carryover impact, and any STORED ballot-access / candidate-turmoil facts.

High-level orientation for AI clients new to the simulator.

DISCOVERY — find the right tool when nothing in your list fits, like survey ingest or polling, by searching the whole catalog including gated tools.

OBSERVABILITY — session usage meter: total api_calls (every tool invocation since this server session began), distinct tools used, a by_category breakdown, and the per-tool leaderboard.

WITNESS STREAM (EM-116) — replay the ordered server-side event log of every tool-call (a running then a done event each, carrying category, latency_ms, args_digest, affected{precinct_ids,count}, delta{margin_shift}, scenario_id, version, channel).

WITNESS AUDIT (EM-116) — re-verify the immutable, content-hashed audit chain of a scenario's committed versions (commit_version is the append-only hash-stamped write).

Return the ordered 2028 primary calendar for D or R: state by state, with date, type (primary/caucus), delegates, and tier (carve-out / super-tuesday / april).

Define the candidate field for a party's presidential primary on this simulation (the GOP/Dem contenders).

Remove a candidate from a party's presidential-primary FIELD and REDISTRIBUTE their modeled vote share to the survivors in one atomic, provenance-carrying edit — the "so-and-so drops out, where do their voters go?" primitive (dropouts are recurring news in every contested primary).

Set a party's presidential-primary vote shares — one state, or MANY states in a single call.

Model a party's presidential primary at COUNTY level: set one county's candidate vote shares within a state's primary.

Model a party's presidential primary at PRECINCT level — the finest grain.

BULK conditional primary edit — for every precinct in a HOUSE district that matches a 2024 cohort filter, set the candidate shares, in ONE call (instead of one set_primary_precinct_shares per precinct).

BULK primary-share writer — apply a party's presidential-primary shares across MANY geographies in ONE call, instead of one set_primary_shares / set_primary_county_shares per geo.

Build a multi-step STRATEGY PLAYBOOK for a HOUSE / state-leg district, in one call.

Return the saved strategy playbook for a simulation (s.strategy), or {strategy:null} if none.

Clear the strategy playbook — the one-call reset for the plan.

Remove a state's primary vote shares for a party (un-model that contest).

Move the calendar playhead — the point in the primary calendar "as of" which to view the race on the map/chart.

Pin which modeling grain DRIVES a state in a party's presidential primary — i.e.

Set a candidate's GLOBAL DEMOGRAPHIC DIALS in a primary — how many points to shift them among a voter group across the whole district/state.

Generate a two-path comparison that the browser renders side-by-side.

The running delegate count — OR, for a race-scoped downballot sim, that race's own share rollup.

ONE STATE's primary exactly as the delegate count sees it — the per-state READ view of roll_up_primary.

SCENARIO TRUST plausibility lint (tk_57e0d6adfac63d) — a READ-ONLY reality check over a presidential-primary scenario's ACTUAL rollup, run before you publish or hand off.

SCENARIO TRUST cross-scenario consistency sweep (tk_57e0d6adfac63d) — do this workspace's primary scenarios contradict each other?

SCENARIO TRUST elicitation gate (tk_960747792b23d3) — the HONEST STARTING POINT for a 2028 presidential-primary scenario, in one call, before any share is invented.

SCENARIO TRUST assumptions ledger (tk_960747792b23d3) — record a question you asked the user (or a premise you were given) and the answer that now drives this scenario's modeling: "Does the field consolidate after Super Tuesday?" → "Yes, behind Whitmer — the user's stated premise".

SCENARIO TRUST claim checker (EM-049 / tk_4907f0676a5c7c) — stress-test a public claim ("Whitmer wins the Michigan primary via consolidation") by translating it into the EXPLICIT assumption set the delegate kernel would need, each grounded in real platform data.

PATH-TO-THE-NOMINATION explainer — for each candidate in a presidential-primary scenario (or one candidate_id), a DERIVED, plain-numbers account of HOW they win or WHY they fall short, straight from the delegate rollup.

Define the Democratic primary calendar order + dates (the DNC has not set the 2028 schedule, so the user/AI models it).

Discard the simulation's user-defined Democratic calendar and revert to the default 2024-based Dem calendar.

STRATEGIC KNOWLEDGE — the documented ruleset + knowledge for a geography, so an AI does not have to KNOW the rules; the platform supplies them.

Write your workspace CUSTOM overlay for a geography — campaign-specific notes, target shares, turf intel, local relationships, assumptions — layered ON TOP of (and able to override) the global canonical layer read by get_geo_knowledge.

List your workspace's CUSTOM geo-knowledge overlays (the rows set_geo_knowledge has written), newest grain first.

Save a NAMED primary-calendar ordering as a first-class, diffable artifact.

List the named calendar orderings saved in your workspace (save_calendar_scenario), newest first, optionally filtered by party.

Diff two calendar orderings — each an id/name of a saved calendar scenario, or the literal "default" (the platform calendar).

Apply a saved calendar scenario BY REFERENCE to a simulation — sets the sim's Democratic calendar to that ordering (reusing the define_dem_calendar path, so the delegate math is untouched).

RANK primary-calendar orderings for a candidate against the sim's modeled per-state delegate hauls — which calendar order best helps candidate X.

Read a REAL, ingested historical PRIMARY result (down-ballot) at state/contest grain — winner, per-candidate vote shares, turnout, precinct coverage — straight from precinct_results, never fabricated.

INFLECTION + SENSITIVITY analysis of a modeled presidential primary — under YOUR scenario's assumptions: not just who leads, but when your modeled race clinches and which contests could flip it.

ATOMIC batch-edit transaction for a PRIMARY scenario — validate, preview, apply, and roll back a whole SET of candidate / share / calendar edits as ONE transaction.

Attach a strategist insight (analysis, recommendation, key finding) to a SCENARIO (simulation_id) or — EM-086 — to a RACE (race_id), the campaign "brain" container that spans the race's scenarios.

WORKSPACE-WIDE typed-fact query for insights (tk_d8e53b6ad55f08).

List insights for a SCENARIO (simulation_id) or — EM-086 — for a whole RACE (race_id): the race's own campaign-level insights PLUS every scenario's insights, aggregated with provenance (scope + scenario_id).

Remove an insight from a simulation by id.

P1 #19 (EM-085) — DELETE a sourced fact previously filed on a CONTEST with attach_contest_fact.

Scope a simulation to one specific race/campaign.

Remove the race scope from a simulation, returning it to national/retrospective mode.

Given a seed county (e.g.

Capture the current state of a simulation as a labeled snapshot.

List all snapshots taken against a simulation.

Roll a simulation back to a previously-captured snapshot.

Turn a simulation into a published forecast article.

Reach of YOUR published forecasts — view counts per published-forecast link in your workspace, so you can see which theses are landing.

Clone a published forecast as a new editable simulation in the caller's workspace.

Take a small set of seed observations ("Newsom +4 nationally, +6 with under-30s, wins NJ") and propose precinct-level mutations from them.

Discover what REAL ingested election results are available to analyze — actual precinct-level returns (from RoutPoint), grouped by state × office × year with district / contest / precinct counts.

DISCOVERY + DIAGNOSTICS for custom REGION GROUPS (multi-state / multi-county / multi-district cohorts — campaign regions, media markets, organizing turf, sales territories).

Clone a BUILT-IN region template (discover them under region_coverage.builtin_templates — MAINE FIRST: "maine-reporting-regions") into your workspace as an ordinary, fully-editable REGION GROUP.

GOVERNANCE — machine-readable provenance for every data layer so you can responsibly cite what you publish: source, provider, vintage, kind (actual | boundary | reference | modeled | user_supplied), method, limitations, and which tools use it — plus a legend and methodology card.

The real result of one race, rolled up from its actual precinct returns: winner + party, margin (pp), Dem/Rep vote totals & pct, turnout, and the candidate list.

CANDIDATE QUALITY — how a real down-ballot candidate ran vs the TOP OF THE TICKET in the same district.

Analytical filter over real precinct returns: closest precincts, precincts a party won, turnout outliers — within one race or across a whole state×office×year.

Aggregate real precinct returns up to county, district, or statewide totals for a state×office×year.

Browse the FULL ballot — every individual contest with real precinct returns, including down-ballot races that aren't districted (sheriffs, county commissioners, judges, school boards, ballot measures, city councils).

The real result of any single contest by its contest_id (from list_actual_contests) — works for every ballot line, including non-districted local races.

Who actually WON a race — the authoritative, certified winner and result from precinct returns, including the 2024 presidential result by state.

CAMPAIGN COCKPIT — one call, the whole state-of-play for any race, president → state house.

The budget ask for a race: net votes needed to flip (half the current margin in votes) × public per-net-vote benchmarks across persuasion/turnout channels, cheapest first.

A ranked precinct target list (the field/turf hand-off) for a race — closest-margin precincts first, each with its winner, margin, turnout, and net votes to flip.

COST-TO-FLIP FRONTIER — the single most-asked strategic question: how big a swing across how many precincts flips this race?

Campaign playbook — call this FIRST when the user is campaign staff (manager, finance, field, data, or the candidate).

Ground a budget in the margin: given $ to spend on a race, returns how many net votes it buys per channel (budget ÷ public $/net-vote benchmark) and how far that moves the margin — current margin → new margin, and whether it flips.

A monitoring board for a slate of races: one call returns each race's rating, margin, net-votes-to-flip and turnout, plus a compact snapshot.