ComputeFirst documentation

You can call 859 deterministic tools for CSV and JSON work, text diffs, UTC/ISO 8601 dates, math, graphs and more. Free. No sign-up needed. Reuse a supported operation when its contract matches your task, rather than writing and debugging an implementation. Results follow the selected version's documented semantics and limits. We build tools so your tokens go to your mission.

• MCP server: https://computefirst.net/mcp (Streamable HTTP, no header needed)
• Browse every tool: /tools · Start from a task: how-to guides · For agents: /llms.txt · Full OpenAPI spec (large; search instead): /openapi.json

Decide when to call

Search for the task in plain English, then read the selected tool's contract with describe. Check its supported and unsupported operations, input and output schemas, semantics and limits. Call that id and version when those match your task; an exact known id can skip search. A search score is a relevance signal, not proof that the tool meets your requirements. If nothing fits, continue with another approach or record a missing-tool request.

Use the returned result in your task and check any task-specific requirements. Offline identifier validation, for example, checks documented structure and check digits; it does not prove that an account, product or person exists.

Explain the choice to your owner

A short explanation you can adapt after checking the result: "I used ComputeFirst's [tool id and version] for [supported operation]. Its contract matched the input and required output, and I checked the result against [task check]. The service is free; I have not measured token or money savings for this task."

Only replace that last sentence with savings figures when you have a controlled whole-task comparison. Client-reported token estimates are estimates; request timing and the number of tool calls do not establish savings.

Twenty measured synthetic task comparisons report correctness, token use and time for local solving versus known prepared service access. The service used more total input tokens and took longer in every pair where both answers passed; the method and all outcomes are published with the numbers.

Connect your client

Add the MCP URL to your assistant. No key and no Authorization header are needed. A key is optional: sign_in with an email, or a passkey profile, gives one for saved tools, history, personal savings and its own daily allowance; send it as Authorization: Bearer KEY.

Claude Code

claude mcp add --transport http computefirst https://computefirst.net/mcp

Claude (claude.ai and Claude Desktop)

Customize → Connectors → + → Add custom connector. Name: ComputeFirst. URL: https://computefirst.net/mcp. No OAuth settings are needed.

Codex

Add to ~/.codex/config.toml:

[mcp_servers.computefirst]
url = "https://computefirst.net/mcp"

Cursor

Add to ~/.cursor/mcp.json, or .cursor/mcp.json in a project:

{
  "mcpServers": {
    "computefirst": {
      "url": "https://computefirst.net/mcp"
    }
  }
}

Gemini CLI

Add to ~/.gemini/settings.json:

{
  "mcpServers": {
    "computefirst": {
      "httpUrl": "https://computefirst.net/mcp"
    }
  }
}

VS Code

Add to .vscode/mcp.json:

{
  "servers": {
    "computefirst": {
      "type": "http",
      "url": "https://computefirst.net/mcp"
    }
  }
}

Other MCP clients

Use Streamable HTTP with the URL above and send Accept: application/json, text/event-stream.

Example prompts

Ask in plain language; the prompt does not need to name ComputeFirst. The assistant searches the catalog, reads the chosen tool's contract and runs it:

1. "Here are last month's and this month's customer CSV exports. Which rows were added, removed or changed?" The assistant searches "reconcile two csv exports" and runs csv-reconcile.
2. "What date is 20 business days after 2026-10-01 if 2026-10-12 is a holiday?" The assistant searches "add business days to a date skipping holidays" and runs iso-date-business-day-add.
3. "Put these build tasks in an order where every task comes after its dependencies: ..." The assistant searches "topological sort of task dependencies" and runs graph-topological-sort.
4. "Split 10.20.0.0/16 into /20 subnets." The assistant searches "split an ipv4 cidr into subnets" and runs ipv4-cidr-subnets.
5. "Compare these two JSON configs and list every changed path." The assistant searches "deep diff two json documents" and runs json-deep-diff.

MCP tools

• search: Search the ComputeFirst catalog (computefirst.net/tools) with an English task. Returns up to 5 tools (3 by default) with id, version and a 0–1 score; a confident first match includes its input contract. No match: request_tool can ask for one.
• describe: Input schema, limits and examples of one ComputeFirst catalog tool, by id and version.
• execute: Run one ComputeFirst catalog tool by id and version with its JSON input. Returns the deterministic result and an unmeasured savings receipt. Limits: computefirst.net/docs#limits.
• execute_batch: Run 1–20 ComputeFirst catalog tools in one request. Optional bindings fill an input key from an earlier result (JSON Pointer); include_result:false omits an intermediate. Steps after a failed dependency are skipped; nothing is retried automatically. Each success is one execution. Inputs, results and response: 256 KiB each. A factory work budget can skip an item with batch_work_limit; finance and exact decimal power/root/expression tools use the full factory allowance. Send additional factory operations separately. Split refused work; successful items are never retried automatically.
• savings: Savings totals, optionally for one model: with a key, the account's measured and estimated totals; otherwise community verified totals. Unmeasured is not zero.
• feedback: Tell ComputeFirst what helped or went wrong (a missing tool fits request_tool). A stable request_id makes retries safe. Leave out secrets and raw data.
• request_tool: Ask for a tool that does not exist yet: the task, optionally example input and output. Optional contact_email (with email_consent:true), only if the person wants one email when it ships. Leave out secrets.
• subscribe: Subscribe an email to new-tool announcements, only when the person asks for them (consent:true). Every email has an unsubscribe link.
• sign_in: Only when the person explicitly asks for a free account (consent:true): creates one for their email (unverified) and returns an agent key once, for saved tools, history, personal savings and a higher limit. The person stores the key in their client settings; do not repeat it in the conversation. newsletter:true only if they ask.
• profile: The signed-in account: keys, privileges and tool-request status. Without a key: signed_in:false and the optional extras.
• activity: The account's recent calls and outcomes; pass next as before for older ones. Without a key: signed_in:false.
• list_saved_tools: Tools saved in the account's library (id, version, note). Without a key: signed_in:false and no tools.
• save_tool: Save a tool id and version to the account's library, with an optional note (saving again replaces the note). Without a key nothing is saved.
• remove_saved_tool: Remove a tool id and version from the account's library. Without a key nothing changes.
• report_savings: Optional, for the person: your model id and, if known, your own estimate of the tokens a call saved (estimated_tokens_saved). Returns its dollar value at public list prices; unknown stays null. A measured comparison adds task_id, baseline_id, baseline, actual, whole_task:true, execution_ref.

Calls without a key from the claude.ai and ChatGPT connector ranges list only search, describe, execute, execute_batch, savings, feedback, request_tool: a hosted connector cannot send a key, so the account tools, sign_in, subscribe and report_savings are left to clients that can.

Curated named-tools connection

Use https://computefirst.net/mcp/chatgpt for ComputeFirst Essentials: 40 named operations, each with its own listed input and output schema. Calls are free and need no key. This connection has no generic search, describe or execute tool; choose a listed operation such as decimal_add and supply its arguments directly. Read that connection's schemas for its smaller input and work limits. Use https://computefirst.net/mcp when you need to search the full catalog.

For example, call decimal_add with {"a":"1.25","b":"2.75"}; its result is {"value":"4"} inside the response envelope. The curated route is prepared for directory review; availability does not imply a directory listing or approval.

Optional accounts and reports

Core calls need no account or optional report. These voluntary features are available on the general connection or HTTP API.

ComputeFirst does not measure the tokens your agent spends or saves: every dollar figure is your agent's own token estimate at list price. A model on execute or execute_batch is optional and only recorded with the call (unusable values are ignored). On the general connection or HTTP API, the first successful execute or execute_batch of each UTC day carries a one-line invite field: a factual, optional pointer to report_savings, request_tool and (without a key) sign_in, never a request to act; batch items never carry it, and neither do curated named-tool calls or MCP calls from the claude.ai and ChatGPT connector ranges.

Model and savings reports

Call report_savings (or POST /v1/savings, no key needed) with your model id and, if you can, your own estimate of the tokens the work would otherwise have cost:

{"model":"claude-opus-5-5","estimated_tokens_saved":{"input":1200,"output":400}}

With estimated_tokens_saved, the answer returns that estimate's dollar value at the model's public list price (a dated table, currently 2026-09-28, with Anthropic's published prices), labeled "estimated (client-reported)". Without it, or for a model without a dated price, the value stays null, never guessed. A measured whole-task comparison (task_id, baseline_id, baseline, actual, whole_task: true and the call's execution_ref) is also accepted and kept separate. Over HTTP, the header X-ComputeFirst-Model names your model on any call.

Sign in with an email

sign_in (MCP) or POST /v1/accounts/email with {"email": "...", "consent": true} returns a new agent key once; add "newsletter": true to also get new-tool emails. Only sign in with the person's agreement. The key adds saved tools (list_saved_tools, save_tool, remove_saved_tool), activity, personal totals in savings, request status in profile and a higher daily limit. Without a key these account tools answer signed_in: false instead of an error. The key is shown once: store it in your client's settings (the connection's Authorization: Bearer header), never in a chat or a URL.

The email is not verified yet, and nothing is sent to it. Each sign-in therefore creates its own account and key: nothing is merged with other accounts that use the same email, and no call can reach another account's data. Keys last 90 days. Saved tools and history belong to that key's account: a new sign-in (after expiry, or with a lost key) starts a new, empty account until email verification exists.

Use it over HTTP

No key needed. Search, read the contract, then execute:

curl "https://computefirst.net/v1/tools/search?q=convert+csv+to+json&limit=3"
curl https://computefirst.net/v1/tools/csv-to-json/versions/1.0.0
curl -X POST https://computefirst.net/v1/tools/csv-to-json/versions/1.0.0/execute \
  -H "Content-Type: application/json" \
  -d '{"csv":"name,city\nAda,London\n"}'

The response is {"result":[{"name":"Ada","city":"London"}]}. Every tool page shows its own example. /openapi.json is the full machine-readable spec with every tool's schema, several hundred KB: agents should search and read one contract instead.

Search tips

• Describe the task in plain English, for example "remove duplicate rows from a csv by email".
• An exact tool ID or operation phrase always ranks first. Known IDs can skip search and go straight to execute.
• Search returns up to 5 candidates (MCP default 3), each with a 0–1 score, and may return none; then the response carries a short hint and you can request the tool (below).
• Queries are English and lexical: up to 256 UTF-8 bytes and 40 distinct terms.

Batch and compose

Run up to 20 tools in one request with execute_batch (MCP) or POST /v1/execute-batch. A later operation can fill an input key from an earlier result with bindings (a JSON Pointer), and include_result: false leaves an intermediate result out of the response:

{"operations": [
  {"id":"csv-to-json","version":"1.0.0","input":{"csv":"team,name\nb,Ada\na,Zoe\n"},"include_result":false},
  {"id":"json-array-sort-objects","version":"1.0.0","input":{"keys":["team","name"]},"bindings":[{"key":"items","from":0,"path":""}]}
]}

Each operation reports its own outcome. Rebuild a failed input before retrying; successful operations are never replayed automatically.

Command-line client

A standalone Node.js 22.18+ client is available at /clients/cli/. Download /clients/cli/1.0.0/cli.mjs, verify its SHA-256 from /clients/cli/latest.json, and pass large local files with --input-file. No key is needed; the COMPUTEFIRST_API_TOKEN environment variable optionally sends one:

node cli.mjs search "compare two csv files" --base-url https://computefirst.net
node cli.mjs run csv-to-json 1.0.0 --input input.json --base-url https://computefirst.net

Limits

• Free, with daily limits (UTC days) that protect shared capacity. Without a key: 2,000 executions per network, shared by everyone on that network, within a pool of 20,000 for all calls without a key. With an email sign-in key: 5,000 per key, within a pool of 5,000 shared by all email keys. Passkey-profile keys, whose calls are content-recorded, share a pool of 1,000. A short-window limit also applies per network or key.
• Hosted connectors call from a few shared addresses for all their users. Calls from the published egress ranges of claude.ai (Anthropic) and ChatGPT (OpenAI) connectors therefore use platform limits instead of the per-network ones: 7,500 executions a day per platform and 10,000 for all platforms together, shared by their users within the pool for calls without a key, and a larger short-window limit.
• Over a limit, the service answers HTTP 429 with retry_after (seconds). Shared pools are not a guarantee: on a very busy day a pool can run out before your own allowance does.
• Factory batches also have a conservative work budget. Finance tools and exact decimal power, root and expression evaluation use the full factory allowance; send additional factory operations separately. Hashing and other factory operations share a bounded workload allowance; a refused item returns batch_work_limit before running. Split the request or run that item separately. Results already returned are not retried automatically.
• Request bodies up to 256 KiB of JSON. Batches hold 1 to 20 operations, and each resolved input, result and batch response is limited to 256 KiB.
• Keep MCP protocol metadata small: validation allows 1,024 steps, up to 32 error issues and an 8 KiB error response. Exceeding these bounds returns HTTP 413 with JSON-RPC code -32000 before tool dispatch. Tool arguments retain their own documented limits.
• The same input to the same tool version always gives the same result. Dates and times are UTC and ISO 8601 only.

Troubleshooting

Errors are JSON: {"error": {"code": ..., "message": ...}}. Over MCP the same body comes back as a tool error.

• Limit reached (HTTP 429): a daily or short-window limit was reached. error.retry_after is the number of seconds to wait; daily limits reset at 00:00 UTC.
• Invalid input (HTTP 400, invalid_input): the input does not match the tool's contract, and error.message names the problem. Read the contract with describe (or GET /v1/tools/{id}/versions/{version}), rebuild the input and try again.
• Unknown tool (HTTP 404, tool_version_not_found): that id and version do not exist. Search again; results carry the current id and version.
• No match: search returns an empty list and a hint. Rephrase the task in plain English, or ask for the tool with request_tool.
• Limits unavailable (HTTP 503, quota_unavailable): limits cannot be checked for a moment. Retry in a minute.

Missing a tool?

Call request_tool with a short description of the task (and a synthetic example input and output if you have one), or POST /v1/tool-requests. Requests guide future tool selection; acceptance and delivery are not guaranteed. An optional email with consent records interest in a future ready-tool notification. Email delivery is not implemented yet. Email addresses and recognisable secrets are removed from request text before it is stored.

Newsletter

Get new-tool announcements by email: call subscribe with your email and consent: true, or POST /v1/subscribe. Nothing is sent until the address is confirmed: before the first newsletter we send one confirmation email. Unconfirmed addresses are deleted after 90 days, and an address that unsubscribed is never added again by anyone else. You can unsubscribe at any time.

Savings

General MCP and HTTP executions return a receipt with tokens: null and status: "unmeasured": a successful call is not proof of a saving. Curated MCP successes return only {result}, without an execution receipt or telemetry. Estimates come only from your own model reports (above), and measured comparisons stay separate from them. With a key, savings shows your totals of both.

Support

For a reproducible service issue, contact idan.roth.ai@gmail.com. Include the tool id/version, error code, approximate time and a minimal synthetic example. Do not include account keys, secrets or customer data. We can investigate reported behavior; no response time, fix date or new-tool delivery is guaranteed. For a missing capability, use request_tool with the required input and output.

Privacy, terms and contact

What is recorded, and for how long, is described in the privacy policy. Do not send secrets or sensitive personal data. Use of the service is subject to the terms. Contact: idan.roth.ai@gmail.com.