Model orchestration · BYOK
Pick model, temperature and response format per project. Bring your own key for any provider — OpenAI, Anthropic, Google and more. Keys stay yours; swap providers without a rewrite.
The Ego layer for LLMsGive your LLM
Give your LLM
an Ego.
The seat of your AI’s mind. No backend to build, no vector DB to run, no guardrails to wire — one /ask endpoint with the whole brain behind it.
Scroll to read on
Two ways in
Same /ask, your ergonomics
1import { EgoX } from '@egox/client';
2
3const egox = new EgoX({
4 apiKey: process.env.EGOX_API_KEY,
5 tenantId: process.env.EGOX_TENANT_ID,
6});
7
8const res = await egox.ask({
9 message: 'What is the refund policy?',
10});
11
12console.log(res.answer); // grounded, observable
Use the SDK when…
You’re on Node/TypeScript and want streaming, automatic retries, webhook verification and thread helpers without writing plumbing.
Use the API when…
You’re in Python, Go, Ruby, PHP — or anywhere else. One authenticated POST and you get the same orchestrated answer.
1 call
replaces your whole AI stack
8 steps
in every deterministic /ask
100%
tenant-isolated by design
0 logs
needed to debug a turn
Infrastructure, not glue
Where your LLM’s brain lives
EgoX isn’t “just an orchestrator.” It’s the placement of the LLM brain in your stack — the RAG, the tools, the guardrails and the memory, handled. No backend to build, no vector database to run. You connect your agent and ship.
Without EgoX
You build and babysit all of this
- Stand up and scale a backend service
- Run Postgres + pgvector for embeddings
- Build a chunking & embedding pipeline
- Hand-wire prompt-injection & compliance checks
- Manage threads, retries and rate limits
- Write glue code for every model provider
- Build dashboards to see what happened
With EgoX
One /ask — we handle it
- RAG — chunked, embedded, stored and retrieved for you
- Tools & endpoints — called with storm protection
- Guardrails — injection, compliance and quota built in
- Threads & memory — stateful out of the box
- Analytics & audit — every turn observable
- Connect your agent — one /ask and it’s wired in
Your keys. Any provider. Always.
EgoX is BYOK-only. Your model keys stay yours — billed directly by your provider, never resold or marked up. Bring whichever model you trust; EgoX respects it and orchestrates the rest.
OpenAIAnthropicGoogle GeminiMistralAzure OpenAICohereGroqTogether AI+ your provider
Why it’s called EgoX
The architecture of a digital psyche
In Freud’s model the Ego mediates between raw instinct and conscience, grounded in reality. EgoX plays exactly that role for your AI: it reconciles what the user wants with what’s allowed — and what’s true.
Id
The impulse
Every request lands as raw intent — unfiltered, immediate, hungry for an answer. It is your app’s drive to act.
→ Incoming /ask messages
Ego · this is EgoX
The mediator
EgoX reconciles impulse with reality — routing the model, retrieving knowledge, calling tools and remembering context, so instinct becomes a grounded, defensible answer.
Model routingRAG retrievalTool executionMemory
Superego
The conscience
Safety rails, compliance guard, quotas and audit hold every response within bounds. It keeps the system honest.
→ Guardrails · compliance · quota
Id → Ego → Superego · the psyche returns on the pricing page as two plans: Id Ego, free — and Superego, in charge.
How the Ego thinksWhat happens inside one
What happens inside one /ask
Every request runs the same deterministic pipeline. Expensive LLM calls only fire when intent classification says they’re justified.
01
Authenticate & resolve tenant
Nothing touches data before EgoX knows whose isolated path it's on.
02
Load tenant context
Config, enabled tools, knowledge-base scope, prompt overrides, extensions.
03
Load conversation state
Prior turns from the thread — by EgoX id or externalThreadId.
04
Classify intent
vanilla / RAG / tools / RAG+tools — cheap, deterministic, language-agnostic.
05
Assemble context
History + retrieved chunks + tool catalog, exactly as the intent needs.
06
Call the LLM
The right model and system prompt for the classified intent.
07
Execute tools safely
Dedup, per-tool caps, error classification, transient retry, iteration cap.
08
Persist & return
Message, token usage, intent and audit flags — then a rich response payload.
Capabilities
Everything an AI feature needs, behind one door
Configuration over forking. Behaviour differences between projects live as data — never as branched code.
Knowledge base (RAG)
Ingest documents, chunk and embed with pgvector, and retrieve the right context automatically — scoped strictly to the tenant.
Tools & endpoints
Register REST / GraphQL endpoints the LLM can call. Storm-protected with dedup, per-tool caps and transient-error retry.
Conversation memory
Stateful threads with full turn history. Bring your own conversation id with externalThreadId — no UUID round-trips.
Safety & compliance
Prompt-injection detection, compliance guard and incident logging. Defense in depth — no single failure mode takes the system down.
True multi-tenancy
Every row, read and cache key is scoped by tenant. There is no global data path that bypasses isolation.
Observability is the product
Console: configure, monitor, audit
If the only way to debug a feature is reading server logs, it’s half done. Every runtime event surfaces as a metric, an audit row, or an operator signal.
Analytics
Usage, cost and token breakdowns by day, model and intent — with CSV export.
Tool health
Execution tracking, failure classification and alerts over every tool run.
Thread auditing
Inspect any conversation turn-by-turn with intent and recovery flags.
Compliance log
Incidents captured, classified and retained for review and reporting.
One product, two vocabularies
The Console speaks product language; the backend speaks domain language. Both are correct — neither leaks into the other.
ConsoleBackendWhat it is
ProjectTenantIsolation unit that owns everything below it
AI ConfigurationTenant ConfigModel, temperature, response format
EndpointsToolsExternal APIs the LLM can call
Knowledge BaseRAGEmbedded content the LLM retrieves
Tool HealthExecutions + AlertsObservability over tool runs
Give your AI an Ego it can answer for.
Objective, observable, multi-tenant orchestration a non-ML team can run in production.