The new
way to code.

Built from the ground up in rust around developers, agents, and the work between them.

sansa-routerfix/fallback-cooldown

sansa-router

src

app

layout.tsx

page.tsx

lib

router.ts1M

provider-registry.ts

cost-estimator.ts

latency-tracker.ts

health.ts1M

timeout.tsU

hooks

use-usage.ts

use-latency.ts

types

completion.ts

tests

router.test.ts

fallback-chain.test.tsM

package.json

tsconfig.json

README.md

router.tsCode Map

13interface RouteOptions {

14 maxCostUsd?: number;

15 maxLatencyMs?: number;

16 preferredProvider?: ProviderId;

17}

19const DEFAULT_OPTIONS: Required<Omit<RouteOptions, 'preferredProvider'>> = {

20 maxCostUsd: 0.02,

21 maxLatencyMs: 4000,

22};

24const FALLBACK_ORDER: ProviderId[] = ['anthropic', 'openai', 'google', 'meta'];

26function scoreCandidate(candidate: Provider, request: CompletionRequest, options: RouteOptions): number {

27 const latency = getP50Latency(candidate.id);

28 const cost = estimateCost(candidate, request);

29 const latencyPenalty = latency / (options.maxLatencyMs ?? DEFAULT_OPTIONS.maxLatencyMs);

30 const costPenalty = cost / (options.maxCostUsd ?? DEFAULT_OPTIONS.maxCostUsd);

31 return 1 - (latencyPenalty * 0.6 + costPenalty * 0.4);

32}

34export async function routeCompletion(

35 request: CompletionRequest,

36 options: RouteOptions = {},

37): Promise<RouteDecision> {

38 const candidates = PROVIDERS.filter((provider) => provider.supportsModel(request.model));

40 if (candidates.length === 0) {

41 throw new Error(`No provider supports model "${request.model}"`);

42 }

44 const ranked = candidates

45 .map((candidate) => ({ candidate, score: scoreCandidate(candidate, request, options) }))

46 .sort((a, b) => b.score - a.score);

48 const [best] = ranked;

49 const estimatedCostUsd = estimateCost(best.candidate, request);

50 const startedAt = Date.now();

52 try {

53 const response = await best.candidate.complete(request);

54 recordLatency(best.candidate.id, Date.now() - startedAt);

55 return {

56 provider: best.candidate.id,

57 model: response.model,

58 estimatedCostUsd,

59 reason: best.candidate.id === options.preferredProvider ? 'preferred-provider' : 'best-score',

60 };

61 } catch {

62 return routeToFallback(request, options, best.candidate.id);

63 }

64}

66async function routeToFallback(

67 request: CompletionRequest,

68 options: RouteOptions,

69 excluded: ProviderId,

70): Promise<RouteDecision> {

71 for (const providerId of FALLBACK_ORDER) {

72 if (providerId === excluded) continue;

73 const provider = PROVIDERS.find((p) => p.id === providerId && p.supportsModel(request.model));

74 if (!provider) continue;

76 const startedAt = Date.now();

77 const response = await provider.complete(request);

78 recordLatency(provider.id, Date.now() - startedAt);

80 return {

81 provider: provider.id,

82 model: response.model,

83 estimatedCostUsd: estimateCost(provider, request),

84 reason: `fallback-after-${excluded}`,

85 };

86 }

88 throw new Error(`All providers exhausted for model "${request.model}"`);

89}

sansa-router — zsh

Results Review

Ask anything

HighAutoSansa Auto

10tsserverLn 1, Col 1

Subagents

Up to 3,000
tokens per second.

Frontier models are smart, but they write at well under a hundred tokens per second, and most of a coding task doesn’t need that much intelligence. In ngram, your main agent, whether that’s Sansa Auto, Codex, Claude, or Grok, plans the work and hands the pieces to subagents that write it up to thirty times faster.

Resilient fallback chain2,870 tps

Make the fallback chain resilient: skip providers in cooldown, time out slow ones, and cover both in tests.

Split the work into three tasks

Skip Providersstarted working

Time Out Slowstarted working

Fallback Testsstarted working

Read filesrc/lib/router.ts90 lines

3 subagents2 running

Skip Providers+14−2

Time Out Slow+18−0

Fallback Tests+46−3

Ask anything

HighAutoSansa Auto

Predictions

Good prompts without the typing.

Agents do their best work with clear, specific prompts, but writing them takes time you’d rather spend on the problem. ngram predicts what you’re about to write: the rest of your prompt, the next edit in your code, the command you need in the terminal. Press Tab to accept, or keep typing.

Resilient fallback chain

Editedsrc/lib/timeout.ts

Slow providers now time out after maxLatencyMs and the chain moves on to the next one.

Predicted promptescReject⇥Accept

now add tesAdd tests for the timeout path in router.test.ts, stubbing isCoolingDown like the fallback tests do.

now add tes

HighAutoSansa Auto

dev@workstation sansa-router %pnpm vitest run && pnpm tsx scripts/update-router-pool.ts

run the tests and update the router pool

sansa-router — zsh

Codebase graph

Keep up with what your agents write.

When agents write most of the code, it piles up faster than you can read it, and it gets hard to steer them once you lose track of how the pieces fit. ngram draws your codebase as a map of files and the connections between them, so you can see how it’s put together, find what a change will touch, and point your agents at the right place.

sansa-app

feature/agents-ide

Bring your subscription

Make your
plan last the week.

Nothing kills momentum like hitting your usage limit halfway through a task and waiting for it to reset. ngram connects to your subscriptions and sends each request to the model that fits it, so renames and small fixes stop using up the limit you need for the hard problems.

Rename RouteOptions

Rename RouteOptions to RoutingPolicy everywhere it's used.

Thought 0.4s

SearchedRouteOptions9 matches

Ask anything

HighAuto

Select a model…

Sansa Auto

Subscriptions

GPT-6 Astra

GPT-6.1 Sol

Grok 4.6

Grok 4.7

Sansa Auto

Open source, built in Rust

Your editor shouldn’t need a gigabyte.

VS Code, Cursor, and the Codex app are built on Electron, so each one runs a whole web browser to draw a text editor. Put a few agents to work and they eat gigabytes of memory and start to lag. ngram is written from scratch in Rust, which runs many times faster and needs a fraction of the memory.

Memorysame project

AppIdleWith agents