# ScoreCompute

> Specialized Rust computation tools for AI assistants.

Website: https://scorecompute.com/
MCP endpoint: https://scorecompute.com/mcp
Transport: MCP Streamable HTTP. No API key required for bounded public access.
Use MCP initialize and tools/list to discover the current schemas and limits.
Optional focused connection: https://scorecompute.com/mcp?tools=verify_claim exposes only Verify. The service-specific tools query accepts 1–8 distinct tool names; each selected tool keeps its full schema. The ordinary endpoint retains all tools. Reconnect after changing a selection; this is not an authorization boundary.
<!-- PUBLIC_INVENTORY:CATALOGUE:START -->
The catalogue exposes 38 tools: 22 scientific computation tools, 6 independent Discovery study tools, 6 optional composition tools, 3 contributor-network tools and 1 claim-verification tool. Direct scientific and Discovery calls never require the composer.
<!-- PUBLIC_INVENTORY:CATALOGUE:END -->

## Guided first mission
- https://scorecompute.com/guides/first-mission/: copyable English/French request, exact arguments and clearly dated private MCP execution record on synthetic data. No hosted chat model; the caller supplies its assistant.
- https://scorecompute.com/missions/robust-route/: compose_capabilities previews the existing route-risk path; execute_composition runs route_optimizer, the explicit route_durations.v1 adapter and simulate_plan. This assesses one tour, not an optimization of robust tour choice.

## Direct computation tools
- shape_the_sound: inverse design for a connected uniform fixed-edge ideal membrane. Ratios, tolerance windows, numerical search and optional actual mode meshes. Refinement reuses hear_the_shape, not an independent validator; search failure never proves impossibility.
- check_arithmetic: bounded numerical claims with checked exact rational arithmetic where supported; unsupported estimates remain inconclusive. Directly callable independently of verify_claim.
- simulate_pi: seeded Monte Carlo, CPU or NVIDIA CUDA, Wilson confidence interval.
- optimize_tasks: exact 0/1 task selection under an integer time budget.
- simulate_plan: uncertainty simulation for the selected task durations.
- compute_orbit: ideal two-body Keplerian orbit, not an observational ephemeris.
- hear_the_shape: 1–12 vibration modes of a simple 3–64-vertex polygon in metres,
  with fixed or free boundary conditions. P1 finite-element upper bounds and
  Richardson-extrapolated estimates remain distinct; estimated errors are not
  rigorous bounds. Optional wave speed supplies frequencies and notes; optional
  second polygon supplies a finite-resolution spectral comparison. Matching modes
  do not prove isospectrality. No damping, air loading, bending stiffness or holes.
  CPU, direct MCP access only: no planner binding or approved composition adapter.
- propagate_uncertainty: check units for one explicit expression (512 characters,
  1–16 variables), then compare first-order GUM with seeded Monte Carlo under
  supplied normal, uniform, triangular or constant input distributions. Fixed
  10,000–2,000,000 draws, coverage 0.5–0.999; supported correlations are between
  normal inputs. Returns dimensional findings, uncertainty budgets, coverage
  intervals and a linearization/convergence assessment. No unlisted influences,
  effective degrees of freedom, affine Celsius/Fahrenheit units or adaptive draws.
  CPU, direct MCP access only: no planner binding or approved composition adapter.
- verify_shadows: solar position and shadow geometry under supplied assumptions.
- check_ephemeris: approximate Sun/Moon position against a claimed observation.
- audit_statistics: GRIM/GRIMMER arithmetic checks under the stated assumptions.
- analyze_kinematics: angular speed and distance hypotheses, no identification of an object.
- check_shadow_track: temporal shadow consistency under a solar model.
- solve_equilibrium: Kuhn poker strategy via self-play.
- analyze_chess_game: comparison with Stockfish; not evidence of cheating.
- screen_wash_trading: trade-pattern screening; not proof of manipulation.

- route_optimizer: geometric CPU tours for 2-256 points, explicit planar or spherical km.
  Fixed start 0, optional return, all legs preserved. Exact only after complete
  small-instance search; bounded heuristics otherwise. No roads or traffic.

- triangulate_tracks: bounded CPU fit of original timed geometric angle tracks from
  2–4 stationary observers. Constant-velocity spherical ECEF model, declared angular
  standard deviations and supplied fixed clock offsets. Returns estimated,
  inconsistent, degenerate or no_convergence, fitted trajectory and conditional
  component uncertainties and the full conditional 6×6 covariance with units.
  No object identification or real-world accuracy promise. Corrected measurement
  times have a global span <=3600 s, overlapping observers and |t_s|<=1e12 s.
  Contract 0.2.0: interpolation supports initialization/output only, not extra
  independent measurements in the fit. Reduced chi-square >9 is a screening
  convention, not a three-sigma significance test. A complete request has a typed
  direct-tool binding; a fit does not itself supply future acquired observations.

## Method Lab: independent experimental tools
- forge_route_policy: Rust generates, mutates and crosses bounded arithmetic route
  rules using supplied training cases only; complete ancestry and outcome ledger.
  Contract 0.2 uses cost-aware selection with converged-only admission. Logical
  fuel is a work proxy, not CPU cycles; simplification reports keep both hashes.
  Public bounds: 8 cases, 32 points/case, 64 attempted programs, fixed depot 0.
- run_route_policy: explicitly run an experimental bounded AST on 2–128 planar
  kilometre points without retraining. Complete tour and cost checks; exact=false.
- Neither tool automatically replaces route_optimizer or claims superiority.
- A separate sealed study evaluates one locked train-selected candidate against
  nearest-neighbor + 2-opt and cheapest-insertion + 2-opt on fresh held-out cases.
- Interactive formula and 3D tour: https://scorecompute.com/discovery/#method-lab
- Campaign 1 receipts (preserved): https://scorecompute.com/research/method-forge/study.json
- Campaign 2 receipts: https://scorecompute.com/research/method-lab-v2/study.json
- These tools are independently callable; the typed composition catalogue has no bindings for them.

## Independent Discovery study tools
- plan_observation: fit original supplied angular observations, then compare 1-64
  proposed series at one common future horizon. Candidates supply a station,
  3-120 corrected times, angular-noise assumptions and cost; they contain no new
  angles. Inspect predicted versus baseline_rejected and design.status. Ranking
  minimizes predicted major-axis position uncertainty among admissible supplied
  alternatives. Cost is a limit. This is a conditional local linear forecast,
  not an acquired posterior, a globally best viewpoint or a visibility guarantee.
- stress_test_observation: examine 1-32 explicitly hypothetical angle/clock
  perturbations against a reconstruction-stability claim. counterexample_found
  may mean an excessive position shift or no usable reconstruction. none_found
  applies only to examined admissible cases; non-convergence is inconclusive.
- assimilate_observation: refit original observations together with one supplied
  new angular series. Each old/new pair enters once; the original covariance is
  not reused as a prior. data_origin is synthetic or measured as declared by the
  caller, with data_provenance caller_declared_unverified. New readings can worsen
  uncertainty or contradict the model. A mean-position shift is not error against
  known truth. Forecast, before and refit uncertainty remain distinct.
- improve_schedule: enumerate up to 32 permitted deadline/task-removal changes,
  preserve required tasks, compare declared costs and confirm one finalist using
  a separate fixed seed. Search and confirmation each have an error budget of
  0.025; search controls the examined family. At most 10000 samples per evaluated
  alternative plus one confirmation; exact bounds use no fabricated simulation.
  confirmed is conditional on independent uniform duration variation. Minimality
  concerns the examined search-qualified choices, not every possible schedule.

Observation tools derive their baseline from the original supplied tracks.
Client baseline/state/covariance/truth fields, callbacks and unknown fields are
rejected. The constant-velocity spherical ECEF model assumes exact stations and
corrected clocks, and independent angular errors. Original time correction is
corrected_time = t_s - clock_offset_s; proposed/new times are already corrected.
Prediction, supplied data and caller-declared synthetic/measured provenance must
remain separate in explanations. No tool activates a sensor or fabricates new
measurements. Public examples use fixed synthetic data. These are bounded direct
CPU tools, not a public autonomous or adaptive-policy research service.
Laboratory: https://scorecompute.com/discovery/
Methods and limits: https://scorecompute.com/docs/discovery/

## Optional native mission tools
- list_capabilities: inspect native engine contracts, units, assumptions, backend
  and composition readiness, including the new direct-only engines. Catalogue
  inclusion does not imply a planner binding. Use list_composition_capabilities
  for the registered typed bank, which also describes triangulation and bound
  Discovery tools. Optional exact theme filter; unknown themes return
  an empty list. The original robust scheduling family remains available; the typed planner also supports route-risk composition.
- plan_mission: validate a robust scheduling request and preview candidate budgets,
  engine-call and sample bounds, or explicit blockers, without executing engines.
- build_robust_plan: compare up to three task selections in native Rust using
  optimize_tasks and, only when necessary, simulate_plan. Select the highest-value
  examined candidate that meets the requested success target under the stated model.

Mission inputs require items, budget (integer minutes) and uncertainty (0 to 0.5).
Defaults: min_success_rate 0.95, samples 10000 per candidate, seed 42,
max_candidates 3, duration_model independent_uniform, allowed_tools
[optimize_tasks, simulate_plan]. Candidates use nominal, 10% and 20% time reserves.
Limits: 32 tasks, budget 1440 minutes, 20000 samples per candidate, 3 candidates.
Unsupported duration models or missing required tool permissions produce blockers.
Only approved local tools are supported, with no external commands or destinations.

The native executor validates the integer-minute handoff, skips simulation when
an exact worst-case bound suffices, and reuses identical selections within the
same mission. Otherwise it uses fixed seeded Monte Carlo and simultaneous 95%
Hoeffding error bounds across the examined family. A result is inconclusive if
no candidate's lower bound meets the target; selected is then null. This is a
conditional result under independent uniform duration variation, not a forecast
guarantee or a globally optimal robust schedule over every possible selection.

MCP progress messages prefixed SC_MISSION_EVENT: contain actual native event JSON.
The entire mission is one composite MCP call. Its internal engine calls are native
Rust calls, not extra MCP requests. Detailed mission events and results are private
to the requesting client and are not published in the observatory.

## Typed capability planning and execution
- list_composition_capabilities: inspect 22 implemented capabilities (15 base
  engines, four Discovery tools, two explicit duration adapters and one robust
  scheduling composite), 46 versioned fact contracts and reproducible requests.
  hear_the_shape and propagate_uncertainty remain outside this planner bank:
  call them directly. Other proposed engines are not advertised as implemented.
- compose_capabilities: provide goals and available contract IDs, optional allowed
  tools/locality/search bounds and actual tool argument objects. Rust builds a
  dependency graph, explains blocked paths and returns an existing-tool binding
  where available. This is planning only; actual inputs are checked at execution.
- execute_composition: recompile and execute the approved optimize_tasks ->
  selected_durations.v1 -> simulate_plan path. Supply optimize_tasks arguments and
  simulate_plan {budget, uncertainty, samples, seed}; do not supply durations.
  The adapter verifies selected identities, totals, integer-minute units and the
  shared deadline. Real events use the SC_COMPOSITION_EVENT: progress prefix.

A second approved path is route_optimizer -> route_durations.v1 -> simulate_plan.
Supply available contracts route_optimizer.request.v1, route.speed_kmh.v1,
duration.independent_uniform.v1, sampling.fixed.v1 and budget.minutes.v1;
goal simulate_plan.result.v1. Supply inputs.route_optimizer and inputs.simulate_plan,
plus adapters["route_durations.v1"] = {"speed_kmh":60}. The speed is caller supplied
(1-150 km/h). The adapter checks the complete route and converts each leg with
ceil(distance_km / speed_kmh * 60). It refuses zero legs, more than 32 legs and
per-leg durations outside 1-1440 minutes. The deadline is 1-1440 minutes; sampling
is fixed at 100-20000 under the declared independent uniform model. This assesses
one tour; it does not select a more robust tour or predict real traffic.

Structural cost counts graph steps, not measured time, price or scientific quality.
Defaults: local_only true, max_steps 8, max_search_states 512, max_structural_cost 64.
Bounds: 1-8 goals, up to 48 available contracts, 1-16 steps, 1-2048 expanded states.
Missing assumptions or tool permissions are blockers. Search exhaustion does not
prove impossibility. Independent goals form a graph, not independent corroboration.
The executor accepts 1-32 tasks, a 1-1440 minute shared deadline, uncertainty 0-0.5,
and 100-20000 fixed samples. Success means the risk calculation finished, not that
the schedule is safe. A 95% Hoeffding interval concerns sampling under the supplied
model. Empty selections are blocked. Use build_robust_plan to compare the separate
validated family of nominal/10%/20% reserve strategies against a probability target.
Complete triangulation and Discovery requests can bind directly to their existing
tool. These bindings do not create an acquisition adapter: predicted information
cannot satisfy a contract requiring supplied new angles. Allowed-tool constraints
accept up to 19 identifiers and retain required underlying permissions. Only
approved execution bindings run. No arbitrary remote URLs or generated code.
Documentation: https://scorecompute.com/docs/composition/

## System availability
https://scorecompute.com/status.json provides a sanitized timestamped monitoring
snapshot. Discard stale snapshots (90 seconds) and future timestamps (>15 seconds).
Status does not reserve a worker or guarantee a calculation will complete. GPU
presence comes from worker inventory, not a periodic benchmark. Bounded local
service recovery does not resume interrupted jobs or provide distributed failover.

## Interpretation and collaboration
Return the model assumptions and limitations with every result. Physical compatibility
does not establish image authenticity. A contradiction requires examining inputs and
model assumptions. Never label a person fraudulent from these tools.
Call optimize_tasks and simulate_plan independently to control each step yourself,
or use the optional build_robust_plan tool to compare the bounded candidate family.
Among the eighteen scientific tools, only simulate_pi currently implements CUDA.
These synchronous tools follow the connected compute machine and do not use a
persistent queue or distributed failover. The separate contributor network below
has a bounded queue for two fixed synthetic workloads; it never receives private
arguments from the scientific tools or executes arbitrary compositions.

## Public observatory
The website displays declared MCP software client names and tool activity.
Client names and versions are self-reported; the AI model's identity is not verified.
Do not include secrets or personal data in clientInfo. Tool arguments and results
are not published by the observatory. Recent activity is held in memory.

## Contributor network: fixed public computation
Client 0.2.0, wire protocol sc-worker/0.1. Two compiled workloads are supported.
pi_chunk_v1 is a separate indexed 31-bit integer Monte Carlo model, not the
existing floating-point simulate_pi engine. schedule_probe_v1 is CPU-only and
accepts only one of three fixed public scenarios; no private schedule is accepted.
- network_status: read current contributor capacity, busy/available GPUs, offered
  CPU threads, reported GPU memory, worker supported_workloads and observed
  validated samples per second, including a breakdown by workload.
- submit_network_job: queue a synthetic job with {samples:1000000,seed:42,backend:"auto"}.
  Supported samples: 100-5000000; seed: unsigned 32-bit. Workload defaults to
  pi_chunk_v1, with backend auto/cpu/cuda and no scenario_id. For schedule_probe_v1,
  supply scenario_id and backend cpu or auto; CUDA is refused. A queued ticket is
  not a completed result. No custom durations, files or private inputs are accepted.
- get_network_job: pass the returned job_id to read progress or the final receipt.
  Only completed jobs have a final scientific result; queued/running/expired are
  not success. Schedule receipts keep inside and estimate null, and use successes,
  probability and probability_interval_95 instead of a pi estimate.

The three compiled schedule scenarios are:
- single_80_deadline_90: one 80-minute task, deadline 90 minutes.
- pair_60_40_deadline_100: tasks of 60 and 40 minutes, deadline 100 minutes.
- pair_60_40_deadline_110: tasks of 60 and 40 minutes, deadline 110 minutes.
Each sequential task uses an independent 65536-point midpoint duration grid
from 0.75 to 1.25 times its nominal value. This discrete model differs from
continuous simulate_plan. Version: splitmix64-grid16-independent-uniform-quarter-v1.
Completed jobs return a nominal fixed-sample Wilson 95% Bernoulli interval;
it is not a real-world deadline guarantee or an adaptive stopping interval.
Example submission: {"samples":1000000,"seed":42,"backend":"cpu",
"workload":"schedule_probe_v1","scenario_id":"pair_60_40_deadline_110"}.

Workers negotiate supported_workloads at registration. Omission and legacy state
mean pi only. Existing registrations must be revoked and explicitly registered
again to add a workload; replacing a binary does not expand consent. Scheduling
uses only CPU resources explicitly enabled by their owner, even with backend auto.

Every accepted chunk is independently recomputed on coordinator CPU. The network
provides distributed contribution and checked results; this does not establish a net speedup.
worker_reported_ms is untrusted summed worker time and may overlap across workers.
verification_ms is coordinator CPU recomputation; coordinator_wall_ms includes
queueing, transfer and validation. Keep these timing scopes separate.
Chunks contain at most 250000 samples. Jobs expire after 120 seconds; leases
expire after 20 seconds. Work is reassigned only within bounded coordinator
rules. Jobs may fail to finish when clients pause, disconnect or become stale.
Public HTTP equivalents: GET https://scorecompute.com/api/network/v1/status,
POST https://scorecompute.com/api/network/v1/jobs and GET
https://scorecompute.com/api/network/v1/jobs/{job_id}.

Status contains checked_at_ms and stale_after_seconds (45 seconds). A stale or
future snapshot does not establish present capacity. Resource identities and
hardware are declared by clients, not attested. Public aliases, opaque IDs,
hardware offers and synthetic job receipts are public; tokens, installation IDs
and raw device IDs are not published. Do not use personal information as an alias.
Observed throughput is accepted samples in the previous 60 seconds divided by 60.
observed_samples_per_second_by_workload separates the two workloads. The aggregate
mixes different calculations and is not a comparable scientific-work or FLOPS metric.
GPU memory is separate per device, not pooled into a larger model allocation.
The hosted scientific worker inventory is not added to the contributor totals.
Only one physical RTX 4080 SUPER has been used for GPU validation; independent
client processes are not evidence of multiple physical machines or GPUs.

Contributor clients support Windows x64 and Linux x64. Windows is distributed
as a ZIP containing an unsigned executable; Linux as a tar.gz with a glibc 2.39
baseline (Ubuntu 24.04). Published downloads and SHA-256 checksums are available in the contributor
section of the live laboratory. A checksum is not a publisher signature.
The NVIDIA driver must support the embedded PTX; no CUDA Toolkit is required
to run the client. Device failure never silently enables CPU fallback.

Every launch starts paused. CPU contribution is disabled on a fresh installation.
Saved resource choices do not start computation. Explicit Start registers and
enables work. Pause prevents new chunks; an existing small chunk may finish.
GPU choices, 1-8 CPU threads (bounded by the machine) and duty are user controlled.
Duty adds rest periods; it is not a wattage cap or GPU-kernel preemption.
The local dashboard uses loopback and protected controls. The client installs
no automatic startup service and executes only the negotiated compiled workloads.
Guide: https://scorecompute.com/contribute/
Live pool and client downloads: https://scorecompute.com/lab/#network

## Contributor retention and privacy
The coordinator retains at most 128 registrations, including aliases, declared
resources and hashed authentication tokens. Registrations have no automatic
age-based deletion; Pause does not delete them. Revoke removes the active
registration and invalidates assignments, while prior verified job counts remain.
At most 64 job records are kept, with terminal records pruned oldest-first when
new admission needs space. The 120-second execution deadline is not a receipt
retention period. Cumulative totals remain after pruning. IP admission buckets
are memory-only and inactive buckets are reclaimed after 120 seconds. Restricted
operational backups can contain earlier coordinator state; the 50-event MCP
observatory limit is not an infrastructure-wide zero-storage claim.
A separate contributor activity endpoint at
https://scorecompute.com/api/network/v1/activity publishes synthetic transitions.
Its ephemeral ring holds at most 256 events; a response includes at most 128
and a snapshot of up to 16 active plus eight terminal public job receipts.
This 24-receipt snapshot does not change the 64-record persistent job limit.
Events contain job IDs, timestamps, sample counts and sometimes short public
worker IDs/backend, not credentials, IPs, full private worker IDs or aliases.
The website may match short worker IDs to separately published status aliases.
A lease is an assignment, not proof of kernel execution. Reset snapshots are
history and must not be replayed as fresh work or GPU utilization. Coordinator
restart clears event history without removing retained receipts. This journal
is separate from the gateway's 50-event MCP observatory.
Details and contact: https://scorecompute.com/privacy/

## Interactive demonstrations
Gallery: https://scorecompute.com/demos/
<!-- PUBLIC_INVENTORY:DEMONSTRATIONS:START -->
The 30 dedicated pages demonstrate tools of one MCP server. The Discovery laboratory covers its 6 study tools, and /verify/ provides arithmetic and claim verification. The catalogue contains 38 tools in total, not separate servers. Each demonstration provides real example arguments, explained methods and limitations. No calculation or contributor job starts on page load. The conceptual artwork illustrates a theme; it is not a scientific result.
<!-- PUBLIC_INVENTORY:DEMONSTRATIONS:END -->
- [tour_profile](https://scorecompute.com/demos/tour-profile/): Compare a square, a line and two separated clusters. Inspect the supplied positions, then ask Rust for the distance distribution, isolation and directional spread.
- [scan_counterexample](https://scorecompute.com/demos/scan-counterexample/): Declare a comparison, choose a discrete grid and look for a witness. See which cells were visited, where a violation was returned and why silence is never a proof.
- [shape_the_sound](https://scorecompute.com/demos/shape-the-sound/): Choose a chord and ask Rust to design a polygonal membrane. Inspect the returned shape, animate its computed vibration modes and compare requested and obtained tones.
- [kepler_stability](https://scorecompute.com/demos/kepler-stability/): Explore how nearby orbits separate in an ideal Sun–Jupiter system. Turn a grid of starting conditions into a sensitivity map, then inspect what each calculation actually established.
- [hear_the_shape](https://scorecompute.com/demos/hear-the-shape/): Compare two drum shapes, see their calculated vibration modes and listen to individual frequencies. Explore what a finite spectrum can — and cannot — tell you about a shape.
- [propagate_uncertainty](https://scorecompute.com/demos/propagate-uncertainty/): Follow uncertain inputs through a formula. Compare first-order propagation with seeded Monte Carlo, see which inputs contribute most, and catch incompatible units before calculating.
- [plan_golden_hour](https://scorecompute.com/demos/plan-golden-hour/): Choose a date and location. Calculate the golden and blue light windows in one UTC day, including high-latitude cases where familiar sunrise patterns disappear.
- [triangulate_tracks](https://scorecompute.com/demos/triangulate-tracks/): Combine timed angular observations from different locations to estimate a moving object’s 3D position and velocity, with residuals and explicit uncertainty limits.
- [simulate_pi](https://scorecompute.com/demos/simulate-pi/): Turn a seeded cloud of random points into an estimate of π, with a convergence curve and sampling uncertainty you can inspect.
- [optimize_tasks](https://scorecompute.com/demos/optimize-tasks/): Give independent tasks a duration and a value. Rust selects the highest-value combination that fits the stated time budget.
- [simulate_plan](https://scorecompute.com/demos/simulate-plan/): Run a supplied plan through seeded duration variations and see how often it meets the deadline under that chosen model.
- [route_optimizer](https://scorecompute.com/demos/route-optimizer/): Connect supplied points into a complete tour, then inspect every leg, the search method and whether optimality was actually established.
- [compute_orbit](https://scorecompute.com/demos/compute-orbit/): Change the shape and elapsed time of an ideal orbit, then inspect its trajectory, position and orbital period.
- [verify_shadows](https://scorecompute.com/demos/verify-shadows/): Compare a measured shadow with a calculated solar direction after mapping image pixels onto a declared ground plane.
- [check_ephemeris](https://scorecompute.com/demos/check-ephemeris/): Compare a claimed Sun or Moon position with an approximate ephemeris at a supplied place and UTC time.
- [audit_statistics](https://scorecompute.com/demos/audit-statistics/): Ask whether a reported mean or standard deviation passes necessary arithmetic checks for bounded integer observations.
- [analyze_kinematics](https://scorecompute.com/demos/analyze-kinematics/): Convert observed angular motion into transverse speed at chosen distances and inspect the consequences of a claimed speed-distance pair.
- [check_shadow_track](https://scorecompute.com/demos/check-shadow-track/): Compare supplied shadow angles over time with expected solar motion, including individual residuals and the direction of rotation.
- [solve_equilibrium](https://scorecompute.com/demos/solve-equilibrium/): Explore a three-card imperfect-information game with regret-based self-play, a strategy table and explicit exploitability measurements.
- [analyze_chess_game](https://scorecompute.com/demos/analyze-chess-game/): Ask Stockfish to assess supplied positions and compare the played moves with its bounded-depth recommendations.
- [screen_wash_trading](https://scorecompute.com/demos/screen-wash-trading/): Examine a synthetic series for repeated volume at nearly identical prices, with a declared time window and price band.
- [list_capabilities](https://scorecompute.com/demos/list-capabilities/): Inspect the thirteen registered composition-bank tool contracts, their themes, units, backends, assumptions and current readiness.
- [plan_mission](https://scorecompute.com/demos/plan-mission/): Validate a robust-scheduling request and inspect its bounded candidate budgets, required tools and maximum work.
- [build_robust_plan](https://scorecompute.com/demos/build-robust-plan/): Compare a bounded family of task selections, preserving their values while checking whether a declared success target is supported.
- [list_composition_capabilities](https://scorecompute.com/demos/list-composition-capabilities/): Read the implemented engines, two explicit duration adapters and one scheduling composite alongside their versioned input and output facts.
- [compose_capabilities](https://scorecompute.com/demos/compose-capabilities/): Start from available contracts and a desired result. Rust searches registered dependency paths while enforcing permissions and explicit limits.
- [execute_composition](https://scorecompute.com/demos/execute-composition/): Execute an approved route-to-risk chain with checked identities, explicit units, caller-supplied speed and real native progress events.
- [network_status](https://scorecompute.com/demos/network-status/): Read the contributor network’s fresh resource offers, busy GPUs and observed verified throughput without submitting a calculation.
- [submit_network_job](https://scorecompute.com/demos/submit-network-job/): Queue a synthetic π experiment, receive a real ticket and follow counts that the coordinator verifies before aggregation.
- [get_network_job](https://scorecompute.com/demos/get-network-job/): Supply a job_id returned by submit_network_job to inspect verified progress, completion or expiry for that public experiment.

## Golden and blue hour — plan_golden_hour
Independently callable CPU engine. Input: {"date_utc":"2026-06-21T00:00:00Z","latitude":48.85,"longitude":2.35}. The period is one strict UTC day, not the local civil day. Golden elevation is [-4°, +6°]; blue is [-6°, -4°], geometric solar centre without refraction. Returns sorted millisecond windows, midpoint azimuths (nullable near zenith), period-boundary flags, conventional sunrise/sunset crossings at -0.833°, numerical diagnostics and limits. No terrain, weather or beautiful-light guarantee. Solar primitives are shared with the shadow/ephemeris engines: no independent corroboration.
Demo: https://scorecompute.com/demos/plan-golden-hour/
Method: https://scorecompute.com/engines/plan-golden-hour/
Typed complete-request binding: plan_golden_hour.request.v1 → plan_golden_hour.result.v1.

## Validated observation policy
The independent plan_observation tool can return policy_trace: version, evidence SHA-256 and actual execution path. Approved large requests use an exhaustive cached Fisher kernel; small requests retain the reference. A baseline rejection executes no ranking kernel. Inspect https://scorecompute.com/discovery/#capability-lab and https://scorecompute.com/research/observation-policy/study.json. Acceptance concerns a bounded synthetic CPU study, not GPU, network or whole-assistant acceleration. The methods are engineered; evidence packaging and validation are automated.

## Kepler sensitivity

`kepler_stability` (native contract 0.2.0) reports a bounded planar circular Sun–Jupiter parameter map. Low/moderate/high bands measure finite-window separation, not chaos or long-term stability. Each cell includes actual integrated duration and stopping reason. Numerical warnings and uncomputed cells remain explicit; missing diagnostics are null. Radial overlap of the current osculating ellipse is not a physical encounter time. The engine returns no perturbed-trajectory time series. At most 512 cells and 4 million reserved outer steps, CPU only. Independently callable through MCP; no approved composition binding. Method: https://scorecompute.com/engines/kepler-stability/

## Verify
Tool: verify_claim. Domains: numbers, shadow, ephemeris, statistics, route. Explicit structured claims only. Signed scoped receipts attest service origin, never truth. check_arithmetic remains directly callable. https://scorecompute.com/verify/
## Documentation
- [First assistant mission](https://scorecompute.com/guides/first-mission/)
- [Composed route assessment](https://scorecompute.com/missions/robust-route/)
- [Verify a claim](https://scorecompute.com/verify/)
- [Connect your AI](https://scorecompute.com/connect/)
- [Service status](https://scorecompute.com/status/)
- [Evidence and trust](https://scorecompute.com/trust/)
- [Free and Pro MCP access](https://scorecompute.com/pricing/)
- [Build a Rust engine: guide for AI authors](https://scorecompute.com/docs/engine-authoring/)
- [Submit a calculation suggestion](https://scorecompute.com/suggest/)
- [Discovery laboratory](https://scorecompute.com/discovery/)
- [Method Atlas: recorded routes and counterexamples](https://scorecompute.com/discovery/method-atlas/)
- [Discovery methods and contracts](https://scorecompute.com/docs/discovery/)
- [MCP connection guide](https://scorecompute.com/docs/mcp/)
- [Native capability composition](https://scorecompute.com/docs/composition/)
- [Engine library](https://scorecompute.com/engines/)
- [Contributor network and client guide](https://scorecompute.com/contribute/)
- [Privacy and data retention](https://scorecompute.com/privacy/)
- [Access and subscription terms](https://scorecompute.com/terms/)
- [Contact support](mailto:contact@scorezenith.com)
- [Design a polygonal drum for a chord](https://scorecompute.com/engines/shape-the-sound/): Ask Rust to find an ideal fixed-edge membrane matching requested frequency ratios, then inspect its computed shape, vibrations and numerical limits.
- [Check a numerical claim](https://scorecompute.com/engines/check-arithmetic/): Check bounded scalar expressions with exact rational arithmetic where supported, declared tolerances and conservative inconclusive results for floating estimates.
- [Kepler orbital sensitivity map](https://scorecompute.com/engines/kepler-stability/): Survey a bounded grid of initial orbits in a planar Sun–Jupiter model, with finite-window sensitivity, integrated durations and numerical diagnostics.
- [Hear the shape of a polygonal drum](https://scorecompute.com/engines/hear-the-shape/): Compute vibration modes of a supplied polygon, inspect its nodal patterns and compare the spectra of two shapes under an ideal membrane model.
- [Measurement uncertainty with checked units](https://scorecompute.com/engines/propagate-uncertainty/): Compare first-order uncertainty propagation with seeded Monte Carlo for an explicit measurement model, checking physical units before calculating a result.
- [Golden and blue hour windows in Rust](https://scorecompute.com/engines/plan-golden-hour/): Compute golden and blue light windows for one UTC day from explicit geometric solar elevation bands, with separate conventional sunrise and sunset crossings.
- [3D motion from multiple angular observers](https://scorecompute.com/engines/triangulate-tracks/): Estimate a moving object’s position and velocity from timed azimuth/elevation measurements at different locations, with model-based uncertainties and explicit geometry limits.
- [Geometric tour optimization in Rust](https://scorecompute.com/engines/route-optimizer/): Order supplied points into a complete geometric tour with bounded Rust CPU computation, exact small-instance search and explicit heuristic limits.
- [Monte Carlo simulation with Rust and CUDA](https://scorecompute.com/engines/simulate-pi/): Estimate π with seeded Monte Carlo sampling on CPU or NVIDIA CUDA, with a Wilson confidence interval and reproducible results.
- [Exact task selection under a time budget](https://scorecompute.com/engines/optimize-tasks/): Select the highest-value combination of independent tasks under an integer time budget using an exact Rust knapsack solver.
- [Schedule uncertainty simulation](https://scorecompute.com/engines/simulate-plan/): Estimate how often a selected task schedule stays within budget by simulating independent duration uncertainty.
- [Keplerian orbit calculation for AI agents](https://scorecompute.com/engines/compute-orbit/): Compute an ideal two-body elliptical orbit with a Rust solver for Kepler’s equation, including trajectory and orbital period.
- [Solar shadow geometry verification](https://scorecompute.com/engines/verify-shadows/): Compare measured shadow geometry with a calculated solar position using control points, a homography and Monte Carlo uncertainty.
- [Sun and Moon position consistency](https://scorecompute.com/engines/check-ephemeris/): Compare a claimed Sun or Moon position with an approximate ephemeris for a UTC timestamp and geographic location.
- [GRIM and GRIMMER statistics checks](https://scorecompute.com/engines/audit-statistics/): Screen reported means and standard deviations for arithmetic inconsistency under an integer-valued data model.
- [Angular motion and minimum speed](https://scorecompute.com/engines/analyze-kinematics/): Translate an observed angular speed into transverse speed under explicit distance assumptions.
- [Temporal shadow consistency in video](https://scorecompute.com/engines/check-shadow-track/): Compare measured shadow directions over time against expected solar motion at a specified place and date.
- [Kuhn poker equilibrium with CFR+](https://scorecompute.com/engines/solve-equilibrium/): Explore a small imperfect-information game with a Rust self-play solver and compare its result with a known equilibrium value.
- [Chess move comparison with Stockfish](https://scorecompute.com/engines/analyze-chess-game/): Compare supplied chess moves with Stockfish recommendations and inspect an aggregate move-quality profile.
- [Trade-pattern consistency screening](https://scorecompute.com/engines/screen-wash-trading/): Inspect supplied trade records for dense round-trip patterns and repeated volume within a price band.
- [Planar tour instance profile](https://scorecompute.com/engines/tour-profile/): Inspect distances, isolation and shape in a planar point cloud (3–256 points), with explicit handling of coincident points and undetermined principal axes.
- [Bounded counterexample scan](https://scorecompute.com/engines/scan-counterexample/): Bounded deterministic search for a counterexample to a declared arithmetic claim over a discrete parameter box.