scorecompute
Public alpha
COMPUTE FOR INTELLIGENCE

ScoreCompute
accelerates AI.✳

Your AI sets the goal. ScoreCompute composes, runs and checks the calculations.
Independent tools and checked compositions, with explicit assumptions.

Explore Discovery Try the individual tools
ONE IDEA. MULTIPLE ENGINES.
28independent MCP tools
01MCP connection
4Discovery study tools
START WITH SOMETHING YOU CAN SEE

Turn a question into a visible experiment.

All 24 demonstrations
DISCOVERY · CHOOSE THE NEXT EXPERIMENT

Where should
we look next?

Compare viewpoints, challenge the result and see what new information changes.

Enter the Discovery laboratory STRATEGY · MOVE BY MOVE

What did
the next move change?

Walk through a real chessboard, then request the engine’s analysis.

Explore the chessboard MONTE CARLO · CPU OR CUDA

Can randomness
find a circle?

Watch the method, choose your sample size, and measure the actual result.

Explore the simulation
01 / OBSERVATORY

See the calculation happen.

Engines temporarily unavailable MCP HTTP + stdio
NETWORK VIEWConnections follow real MCP calls
THE CONSTELLATION11 laboratory shortcuts. One connection.
01 — Explore5 shortcuts
Your starting pointWeb interface · MCP client
MCPTHE CONNECTION
Where ideas become computation.
Rust CPUEngine unavailable
CUDA ACCELERATIONGPU unavailableCPU depends on engine connection
Disconnected
02 — Understand6 shortcuts
Choose your next computationAmbient halos · call-driven flows
Selected call Available connection — CPU workers · — CUDA GPUs
Checking availabilitySystem status
WebsiteNot confirmed
Web gatewayNot confirmed
MCP accessNot confirmed
Rust workerNot confirmed
CUDA GPUNot confirmed

A recent monitoring sample is not available. Availability is checked independently of calculations. GPU presence comes from the worker inventory, without reserving capacity or running a benchmark. Stale observations are marked unconfirmed.

MCP observer reconnectingWaiting for a clientSelf-reported identity

Client software reports its own name and version; these are not verified. The AI model is unknown. This public log keeps the last 50 events in memory, without calculation inputs or results.

No calls observed yet. Connect an MCP client or run a calculation in the laboratory.

02 / NATIVE MISSION COMPOSER

One mission.
Several ways through.

Give it a goal and your constraints. Rust compares approved plans,
connects the engines and shows why a route was chosen.

NATIVE MCP MISSIONA native Rust decision
Build a robust schedulev0.1

Choose valuable tasks that can finish within your time budget, under a duration model you specify.

YOUR TASKSMinutesValue
Your duration modelEXPLICIT

Each task varies independently, with every duration inside its ±25% range equally likely. This assumption is yours; it is not inferred from real-world data.

Reproducibility & approved tools

optimize_taskssimulate_plan

This composer runs the scheduling family inside the Rust executor. The capability atlas also offers a separate geometric route-to-risk chain.

The composer is unavailable while the compute connection is offline or another calculation is running. Your settings are kept; try again when it is available.

Task details and candidate decisions stay out of the public activity feed.

NATIVE DECISION GRAPHAWAITING YOUR MISSION
YOUR CONSTRAINTS → APPROVED PLANS

Rust chooses the route.

Exact task selection. Explicit uncertainty. A decision you can inspect.

Select
Test
Decide

Send a mission to reveal the native plan.
Nothing executes until you start.

Only events emitted by the Rust executor appear here.
A bounded comparison. No invented tool calls or estimated timings.

The result includes the reasoning.

Compare task value, success bounds and measured work. See when Rust skips an unnecessary simulation or reuses an identical selection.

03 / CAPABILITY ATLAS

See what connects.
Know why it works.

Explore the bank. Follow the contracts.
Let Rust find a route from what you have to what you need.

TYPED BY DESIGNEvery connection has a reason
THE MAP BEHIND THE MISSION

A shared shape is a start.
A valid contract goes further.

Discover registered engines and explicit adapters. Inspect their units, models and prerequisites, then ask the native planner to explain a complete route—or what prevents it.

Reads the live Rust registry. No calculation starts.

Use one engine, or compose an approved path. Independent tools remain directly callable through MCP. The atlas exposes their contracts; the Rust planner checks the connections.

MCP documentation
04 / ROUTE WORKBENCH

Many stops.
One calculated path.

Place the points. Set the rules. Let Rust find the order.
Every segment comes from the engine’s returned route.

GEOMETRY, CONNECTEDIndependent Rust engine · CPU
PLANAR SPACE kilometersEDITABLE POINTS
000.250.250.50.50.750.7511xy1P1 · STARTP1: x 0 km, y 0 km. Arrow keys move this point.2P2P2: x 1 km, y 0 km. Arrow keys move this point.3P3P3: x 1 km, y 1 km. Arrow keys move this point.4P4P4: x 0 km, y 1 km. Arrow keys move this point.5P5P5: x 0.5 km, y 0.5 km. Arrow keys move this point.
Click empty space to add. Drag a point or use arrow keys.5 stops · closed tour

Shape the problem.

P1 is always the start. An open route may finish at any other point.

SELECTED POINT P1

A cooperative time bound, plus a fixed work limit. Small inputs can be solved exactly; an interrupted search is never certified exact.

Euclidean kilometers · no roads or traffic

A distance can become a question about time.

Explore the Atlas’s separate four-point route example, with an explicit speed, rounding rule and uncertainty model. Assess a deadline without treating a geometric distance as a travel-time prediction.

05 / LABORATORY

A question. A real calculation.

Rust calculations · exportable results
Parametersv0.1.0

Discover π through randomness.

Points in a square. A quarter circle.
Random sampling reveals a constant.

The same seed reproduces the same points. Compare CPU and GPU with identical parameters.
Result

From idea to result.

Choose your parameters and run a calculation.
Every result comes from a real Rust engine.

Live results from our compute engine
EXECUTION LOGWaiting for the first call
› Calls, engine handoffs and measured timings will appear here.
05 / LABORATORY SELECTION

11 laboratory shortcuts.

All 15 scientific engines
CONTRIBUTOR NETWORK / EXPERIMENTAL PILOT

Separate machines.
A shared calculation.

Offer a little compute. Follow real assignments and verified results.
Start with one small, public experiment.

Checking the contributor poolCapacity is not confirmed
Available GPUs—Waiting for a current observation
CPU threads offered—CPU contribution is opt-in
Reported GPU memory— GiBSeparate devices, not one memory pool
Observed throughput—Validated samples/s · previous 60 seconds
No current client countHistorical nodes, when shown, are unconfirmed
ScoreComputeAssignment coordinatorEvery chunk is independently recomputed before acceptance.

Waiting for a verifiable network view.

The website is available, but contributor capacity cannot currently be confirmed.

Hardware and aliases are reported by clients. Only accepted calculation results are independently checked. Client instances are not a count of physical machines.

RECORDED CONTRIBUTOR ACTIVITY

Even a short calculation leaves a trail.

Assignments and verified results, recorded by the coordinator.

Activity connection unconfirmed
Public jobContributorCPU verification

Event replay · this diagram does not measure live GPU utilization.

Current jobs & recent receipts

No retained public job to display.

Only public synthetic jobs. Receipts are retained within the pilot’s limits.

Latest recorded transitions

Waiting for a confirmed activity history.

Recent history, not a continuous utilization trace. A chunk assignment does not prove a GPU kernel has started.
PUBLIC SYNTHETIC EXPERIMENTS

A million points.
One auditable estimate of π.

The coordinator splits a fixed synthetic calculation into small chunks. Available contributors request work; the coordinator checks every returned count on its own CPU.

1,000,000 samplesSeed 42pi_chunk_v1
An available contributor is required before this demonstration can start.
CONTRIBUTE ON YOUR TERMS

Your client.
Your start and pause buttons.

  • Starts paused. Registration and work begin only after your visible Start action.
  • Choose GPUs, CPU threads and duty. CPU is off by default.
  • Only compiled public workloads: π on CPU/CUDA and schedule experiments on CPU. No downloaded code or private datasets.
Read the installation guide

Pilot baseline: Windows x64 and Ubuntu 24.04 x64/glibc, subject to the published artifact’s requirements. Compatible NVIDIA drivers are needed for CUDA.

What this pilot demonstrates—and what it measures

The π workload uses indexed integer points; the schedule workload samples independent duration multipliers on a fixed 16-bit grid. Both are separate models from the hosted scientific engines. No random samples are invented by the interface. Observed throughput counts validated samples from all workloads in the last 60 seconds, divided by 60. Different workloads have different costs; this aggregate is not comparable compute power, theoretical FLOPS or a forecast.

The coordinator deliberately recomputes every chunk on CPU. This pilot demonstrates remote contribution and verification; it does not claim a net speedup. Only the contributor pool is counted here: GPUs in the hosted engine’s inventory are not added a second time. A single physical GPU has been used for hardware validation; a tested multi-GPU cluster is not claimed.

Clients may pause or disconnect. Stale resources receive no new work; jobs can expire. Duty is implemented with small batches and rest periods, not a wattage limit or immediate kernel interruption.

ENGINES AND CONTRIBUTORS

Stronger together.

Connect native engines through checked contracts.
Or join the contributor pilot for a shared, public calculation.

Try the native mission composer
TodayPublic site · Rust · MCP · CUDA
PilotOpt-in clients · checked compute chunks
Next to buildMore validated contribution workloads

Connect your AI.

28 MCP tools, including native mission and capability planning, for your assistant. Add this URL to a client that supports Streamable HTTP.

Public MCP connection
{
  "mcpServers": {
    "scorecompute": {
      "url": "https://scorecompute.com/mcp"
    }
  }
}
plan_golden_hourtriangulate_trackssimulate_pioptimize_taskssimulate_planroute_optimizercompute_orbitverify_shadowscheck_ephemerisaudit_statisticsanalyze_kinematicscheck_shadow_tracksolve_equilibriumanalyze_chess_gamescreen_wash_tradinglist_capabilitiesplan_missionbuild_robust_planlist_composition_capabilitiescompose_capabilitiesexecute_compositionnetwork_statussubmit_network_jobget_network_jobplan_observationstress_test_observationassimilate_observationimprove_schedule

Free alpha access with compute limits and no API key. Engines run on our compute machine; an interruption makes them temporarily unavailable. Client software names are self-reported; the AI model’s identity is not verified. The public observatory displays the client name and tools called. Keep personal data out of your client name.

Learn about MCP