Every AI model.
Routed on your device.
DSI Synapse is an open-source router that runs on your machine. For each request it:
- works out what kind of expertise is needed;
- removes what identifies you;
- sends it to the cheapest expert that is good enough: a local model, your own API keys, or the open network.
A slow expert gets a backup, a failed one is replaced mid-answer, and a stronger expert is asked only when the answer looks uncertain.
A router for intelligence, running where your data lives.
Before any model sees a request, Synapse decides what kind of intelligence it needs, how much, who should supply it, and how much of your context may leave the device. The first three steps typically take under a millisecond and never touch the network.
Understand
Classifies the domain on a taxonomy (finance. → finance → general) and estimates difficulty, freshness and tool needs from the request's structure.
Protect
Replaces emails, phone numbers, wallets, accounts, IPs and tagged names with placeholders. It also trims context to what this expert needs. The mapping never leaves the device.
Choose
Scores every expert on domain fit, predicted quality, latency, price, reliability, tools, cache affinity and privacy. Anything below the quality floor is out, however cheap.
Stream & guard
Streams the answer. It starts a backup if the first token is late, and continues on another expert if one fails mid-answer. Cancelling stops all paid work.
Escalate & learn
Asks a stronger or independent expert only when the answer looks uncertain. Every outcome, and your feedback, updates the next decision.
DSI Synapse on your device, DSI Axon in the network, a chat app and a console.
Sign in with email, Google, GitHub or a wallet. You get a chat interface, a console with everything a model provider's dashboard gives you, and a wallet for crypto top-ups (opening soon).
Drop-in APIs
Anthropic Messages, OpenAI Chat Completions, Responses and Embeddings, Gemini generateContent, and MCP. Streaming, tools, vision, JSON schema, files and batches all work.
Local router
synapse runs on your machine and routes across local models, your own keys and the network, with a quality floor and an explanation for every choice.
Chat
A clean chat interface across every model, with auto to let the router pick. Conversations are stored in your browser, not on our servers.
Console
API keys, workspaces, rate and spend limits, usage, cost, logs, members, playground, files, batches, saved agents and alerts.
Pay with crypto
Every account gets a self-custodial wallet. Crypto and card top-ups are opening soon; until then, use your own vendor keys, or run a node for free network chat.
Agent terminal
DSI Agent Terminal (built on Hermes Agent), connected with one API key: curl -fsSL https://decentralised.si/install/agent.sh | bash. Plus the dsi harness that keeps your memory on your own machine.
No daemon? Change one base URL.
Your Decentralised.si key replaces the vendor key. Request bodies, response shapes, streaming events and tool calls stay byte-for-byte what your SDK expects.
The exact model you asked for. Proves compatibility; nothing is substituted.
Shadow mode records what the router would have chosen, at no extra cost.
"This could have cost 72% less." Benchmark mode verifies with real runs.
Let the router pick per request on difficulty, capability, cost, latency and privacy.
from anthropic import Anthropic
client = Anthropic(
api_key="ds_live_...",
base_url="https://api.decentralised.si/anthropic",
)
message = client.messages.create(
model="claude-sonnet-5", # or "auto"
max_tokens=1024,
messages=[{"role": "user", "content": "Explain this code..."}],
)
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: process.env.DECENTRALISE_API_KEY,
baseURL: "https://api.decentralised.si/anthropic",
});
from openai import OpenAI
client = OpenAI(
api_key="ds_live_...",
base_url="https://api.decentralised.si/openai/v1",
)
client.chat.completions.create(model="gpt-5-mini", messages=[...])
client.responses.create(model="gpt-5", input="...")
client.embeddings.create(model="text-embedding-3-small", input="...")
from google import genai
client = genai.Client(
api_key="ds_live_...",
http_options={"base_url": "https://api.decentralised.si/gemini"},
)
client.models.generate_content(model="gemini-2.5-flash", contents="...")
# No code change for SDKs and tools that read base URLs from the environment ANTHROPIC_BASE_URL=https://api.decentralised.si/anthropic ANTHROPIC_API_KEY=ds_live_... OPENAI_BASE_URL=https://api.decentralised.si/openai/v1 OPENAI_API_KEY=ds_live_...
# Optional per-request control, without touching the body. # Omit them and your account policy applies. X-Decentralise-Mode: optimise X-Decentralise-Max-Cost: 0.01 # USD per request X-Decentralise-Max-Latency-Ms: 2000 X-Decentralise-Min-Quality: 0.90 X-Decentralise-Privacy: strict X-Decentralise-Shadow: estimate # off | estimate | benchmark # Every response says what actually answered: x-decentralise-requested-model / -actual-model x-decentralise-actual-provider / -market / -receipt
The cheapest expert that is good enough. Never just the cheapest.
Most AI stacks send everything to one large model, or retry the same request somewhere else when it fails. Synapse decides per request where it should go in the first place, and it can tell you exactly why.
A floor, not a gamble
Every task gets a quality floor and target from its difficulty and your mode. An expert predicted below the floor is excluded, however cheap. If nothing qualifies, the answer is marked degraded, never passed off.
Every route explained
Eight normalised components per candidate, plus plain reasons: "exact domain match, quality above target, within budget". POST /v1/route shows the whole decision without running a model.
Backups that race
If the first token is late, a backup starts; whichever answers first wins and the other is cancelled. In our demo the backup began at 303 ms and answered at 394 ms, where the slow expert would have taken 800.
No interruption
If an expert fails before answering, the next one takes over. If it fails mid-answer, another continues from the exact point it stopped, and you see one reply.
Escalates only when unsure
Uncertainty comes from confidence, completeness and domain fit. Above the mode's threshold, a stronger expert is asked, or an independent one from a different model family, within budget and deadline.
Learns on your device
Time to first token, latency, cost, success and your ratings update each expert's statistics per domain in a local SQLite file. No central server is in the loop.
Everything you expect from a model provider's dashboard.
Run a team the way you would on a vendor console, across every vendor at once.
- API keys, inference or admin, scoped to workspaces
- Rate and spend limits, budget and low-credit alerts to Slack or Discord
- Usage, cost, logs, monthly statements
- Playground with "get code", Files, Batches and saved agents
- Members with owner, admin, developer and billing roles
Pay for AI with the crypto you already hold (opening soon).
Every account gets a self-custodial wallet at sign-in. Send from it, or from any wallet you've linked, and credit is added once the payment confirms on-chain. Or pay by card through the built-in on-ramp. Top-ups are not open yet; this is how they will work.
How billing works
- Your own vendor keys: the vendor bills you directly at its own prices.
- Network and platform models: paid from your credit balance.
- Printable deposit receipts and monthly statements.
- Budget alerts and hard spend caps, so an agent can't run away with your balance.
Say what matters for this request.
A mode sets how quality, speed, cost and privacy are weighed. The quality floor applies in every mode.
| Mode | Quality | Speed | Cost | Privacy | Behaviour |
|---|---|---|---|---|---|
fast | 0.30 | 0.50 | 0.15 | 0.05 | Lowest latency above the floor; tolerates more uncertainty |
balanced | 0.40 | 0.30 | 0.20 | 0.10 | The default |
deep | 0.65 | 0.10 | 0.10 | 0.15 | Raises the floor and escalates sooner |
cheap | 0.30 | 0.10 | 0.55 | 0.05 | Cheapest expert that still clears the floor |
maximum | 0.80 | 0.05 | 0.05 | 0.10 | Strongest expert, plus an independent second opinion and synthesis |
Privacy is separate from mode. public sends text as written; pseudonymised (the default) replaces identifiers; confidential also restricts to local or trusted experts; local_only never uses a remote expert. The hosted API accepts its own policies (passthrough, optimise, cheapest, private, byok_only and more) through the X-Decentralise-Mode header.
Read it, run it, change it.
Every part is public on GitHub:
- the Rust router daemon;
- DSI Axon, the hosted blind router;
- the provider node and the local memory harness;
- the token ledger;
- this site and app.
Install in one line on macOS, Linux or Windows from the download page, or build it from source. The default config uses simulated experts, so you can watch routing, fallback, hedging and escalation work without a GPU or an API key.
# install (macOS, Linux) — Windows: see /download curl -fsSL https://decentralised.si/install/synapse.sh | sh synapse # or build from source (Rust toolchain) git clone https://github.com/Decentralised-si/DSI-Synapse cd DSI-Synapse cargo run --release # ask; watch it route, stream and explain curl -N localhost:7766/v1/ask \ -H 'Content-Type: application/json' \ -d '{"prompt": "Explain Black-Scholes implied volatility."}' # the decision only, no inference curl localhost:7766/v1/route \ -H 'Content-Type: application/json' \ -d '{"prompt": "Write a Rust async TCP server."}' # tests and benchmark cargo test cargo run --release --bin benchmark
Behind the router: an open network anyone can join.
Run one container next to an open-weight model and your GPU serves the network. Verified work earns PAI reward points, recorded on an off-chain ledger today; PAI has not been issued and has no cash value.
- Your memory stays on your device with the
dsiharness - A different provider for every conversation
- Common knowledge gets cheaper every day
- Frontier reasoning on the network is unlocked by stake
Intelligence routed on your terms.
Run the router locally, call the hosted API with one changed URL, or just start chatting.