scorecompute
Public alpha
COMPUTE FOR INTELLIGENCE

ScoreCompute
accelerates AI.✳

Your AI brings the ideas. Our engines do the math.
Simulate, optimize, explore. Watch the engines work together.

Run your first calculation
ONE IDEA. MULTIPLE ENGINES.
11compute domains
01MCP connection
∞possibilities to explore
01 / OBSERVATORY

See the calculation happen.

Engines temporarily unavailable MCP HTTP + stdio
NETWORK VIEWConnections follow real MCP calls
THE CONSTELLATION11 engines. One connection.
01 — Explore5 engines
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 engines
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

Both engines run locally inside the Rust executor. Other domains are not composable in this version.

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 / 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 / ENGINES

Eleven ways to put ideas to work.

Rust inside. Possibilities ahead.
THE START OF A NETWORK

Stronger together.

One engine explores. Another optimizes. A third checks.
Connect capabilities now. Build toward cooperating machines.

Try the native mission composer
TodayPublic site · Rust · MCP · CUDA
FoundationsShards · multiple device support
Next to buildA network of cooperating machines

Connect your AI.

Eighteen 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"
    }
  }
}
simulate_pioptimize_taskscompute_orbitverify_shadowscheck_ephemerisaudit_statisticsanalyze_kinematicscheck_shadow_tracksolve_equilibriumanalyze_chess_gamescreen_wash_tradingsimulate_planlist_capabilitiesplan_missionbuild_robust_planlist_composition_capabilitiescompose_capabilitiesexecute_composition

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