@gabrielsmartin/orbit-sdk

The AI operating system layer. Route intelligently. Save up to 98%.

Every query has a fingerprint. Complexity, creativity, urgency, domain, emotional weight. Right now you're blasting every one of them at GPT-4o. ORBIT reads the fingerprint in milliseconds and picks the right model — automatically, invisibly, without you thinking about it.

What it is: ORBIT classifies queries across 8 axes and tells you which model to use. You make the API call. ORBIT picks the model. Zero proxy. Zero black box. Fully deterministic — you can read every routing rule in fingerprint.js.

What it isn't: a proxy, an API wrapper, or a neural network. It's fast, auditable rules — safety-critical routes (emotional content, crisis) always win, everything else is heuristic.

npm install @gabrielsmartin/orbit-sdk

Why

You're probably doing this:

const res = await openai.chat.completions.create({
  model: "gpt-4o",  // $30/1M tokens — every single query
  messages
});

"Write a haiku" does not need GPT-4o. Only ~15% of real queries do. ORBIT routes the other 85% to cheaper models with equivalent quality for the task.

Usage

import orbit from '@gabrielsmartin/orbit-sdk'

// Route a query — returns decision instantly, no network call
const { model, reason, savings } = orbit.route("write a haiku about recursion")
// model.name → "Claude Sonnet"
// model.id   → "claude-sonnet-4-6"
// reason     → "High creativity — Claude Sonnet for open-ended generation."
// savings.reductionPct → 50

// You then call the model yourself:
const res = await anthropic.messages.create({
  model: model.id,   // "claude-sonnet-3-5"
  messages: [{ role: 'user', content: query }]
})

ORBIT picks the model. Your code makes the call. This keeps your API keys yours and gives you full control.

Examples

import orbit from '@gabrielsmartin/orbit-sdk'

orbit.route("what is 2+2?")
// → Gemini 2.5 Flash | cost_gemini | 98% savings vs GPT-4o

orbit.route("I've been feeling really anxious lately")
// → Claude Sonnet | ethics_first | emotional weight — never a cheap model

orbit.route("latest AI news today")
// → Grok | recency_grok | live web access

orbit.route("architect a distributed event-driven system")
// → Claude Sonnet | complex_code | high complexity + reasoning

orbit.route("summarize this in one sentence")
// → Gemini 2.5 Flash | cost_gemini | low complexity, $0.50/1M tokens

8-Axis Classification

| Axis | What it measures | |------|----------------| | complexity | Depth of reasoning required | | creativity | Open-ended vs. factual generation | | emotional_weight | Sensitive or crisis content | | recency | Need for real-time / live web data | | context_load | Long-document or multi-turn depth | | speed | Latency sensitivity | | domain | Code, legal, medical, creative, general | | cost_tolerance | Budget flexibility (overridable) |

Classification is keyword-based with tuned weights — fast and transparent. You can inspect fingerprint.js and see exactly how any query is scored.

Routing Table

| Condition | Model | Rule | |-----------|-------|------| | Signal = 777 | Claude Sonnet | Completion — capability floor | | Signal = 555 | Grok | Variation — max diversity | | Signal = 333 | Gemini Flash | Foundation — cost floor | | emotional_weight ≥ 6 | Claude Sonnet | Safety-first, always | | domain = legal/medical | Claude Sonnet | Ethics + long context | | recency ≥ 7 | Grok | Live web access | | complexity ≥ 7 + code | Claude Sonnet | Deep reasoning | | complexity ≥ 7 | GPT-4o | Structured output | | creativity ≥ 5 | Claude Sonnet | Open-ended generation | | complexity ≤ 3 | Gemini 2.5 Flash | 98% cheaper, equivalent quality | | Default | Claude Sonnet | Safe fallback |

API

import orbit, { OrbitClient, fingerprint } from '@gabrielsmartin/orbit-sdk'

// Singleton client — zero config
const { model, reason, rule, scores, savings } = orbit.route("your query")

// Custom client
const client = new OrbitClient({
  cost_tolerance: 'low',          // 'low' | 'medium' | 'high'
  blocked_models: ['gpt4o'],      // block specific models
  apiKey: 'your-orbit-key',       // enables usage telemetry (optional)
  signal: '333',                  // default signal code (optional)
  log: true,                      // console.log routing decisions (default: true)
  on_route: (decision) => {},     // callback on each routing decision
})

// Fingerprint only — no routing
const scores = orbit.fingerprint("your query")
// → { complexity: 7, creativity: 2, emotional_weight: 0, recency: 0, ... }

// Session stats
const stats = orbit.stats()
// → { total_queries: 42, total_savings_formatted: '$1.2400', model_usage: { ... } }

Hosted API

Sign up at orbitai.gtll.app to get your API key, then:

curl -X POST https://api.gtll.app/orbitRoute \
  -H "Content-Type: application/json" \
  -H "x-neural-secret: your-api-key" \
  -d '{"complexity": 7, "domain": "code", "signal": "777", "api_key": "orbit_..."}'

Pricing:

| Tier | Price | Limit | |------|-------|-------| | Free | $0/mo | 1,000 queries/month | | Pro | $19/mo | Unlimited · all models | | Team | $99/mo | Unlimited · 5 seats |

→ Upgrade to Pro — $19/mo · Get Team

Dashboard + usage stats at orbitai.gtll.app

The Resonance Vision

ORBIT is the open-source core of Resonance — the AI operating system layer.

Every enterprise AI team is bleeding on token costs. A 50-person team running 1,000 queries/day at GPT-4o spends ~$202,500/year on tokens. With signal-aware routing, that drops to ~$57,700. Resonance captures 15% of savings — you keep the rest.

The signal layer is what makes this defensible. 777 queries generate ground-truth labels: "this type of query needs Claude." 333 labels: "this can run on Gemini Flash." At scale, that's a cross-model performance database no individual model provider can build. Only a model-agnostic layer builds this moat.

ORBIT is the open-source foundation. The routing engine learns from every signal.

Research backing

• RouteLLM (ICLR 2025, UC Berkeley): intelligent routing achieves 85% cost reduction at 95% quality vs always-GPT-4o
• OpenRouter ($500M+ valuation) proves the market exists. ORBIT adds the classification layer OpenRouter doesn't have.
• Martian (Accenture-backed) proves enterprises pay for routing intelligence. ORBIT is the open, developer-first version.

Roadmap

• [x] v0.1.x — 8-axis classification, 6-model routing matrix
• [x] v0.3.x — Signal-aware routing (777/555/333), hosted gateway
• [x] v0.4.x — API key gated usage dashboard
• [x] v0.5.0 — Embedding-based fallback for ambiguous queries + Pro tier unlock
• [ ] v0.6.0 — Multi-provider streaming passthrough (OpenAI / Anthropic / Gemini)
• [ ] v0.7.0 — Team API keys + usage aggregation dashboard
• [ ] v1.0.0 — Enterprise API + savings-share pricing

License

MIT © Gabriel Martin

GitHub · npm

777 · 555 · 333