The backbone your team's AI agents work on.
Alchemyst AI is the context backbone that keeps every agent's knowledge current, traceable and semantically consistent across your entire organisation through a single API.
- p95 latency
- < 300ms
- auditable
- 100%
- zero infra
- 1 API
Alchemyst AI: the institutional context backbone for AI agents
Alchemyst AI is the verifiable institutional context backbone that lets AI agents run day-to-day operations at enterprise scale. Through a single API and its context arithmetic primitive, it gives every agent persistent, traceable context and semantic retrieval over your institutional knowledge graph, keeping knowledge current, traceable, and consistent. Sub-300ms retrieval latency at p95, 99.7% reduction in domain hallucinations, 20x faster debugging, 99.9% uptime SLA, one API with zero infrastructure.
Context arithmetic: the core primitive
Dynamic set algebra over meaning computed at query time. Intersection narrows scope by team, region, or version. Union widens recall across sources. Subtraction removes superseded or out-of-scope content. Ranking keeps only the right context in the window. Memory is derived, not hard-coded: recall what happened, resolve what it means, inform how to act, all from one institutional knowledge graph.
Context traces and semantic consensus
Every agent decision is traceable to the exact context it had, with sources, scores, and rules applied. Define canonical term definitions at the org level so revenue, pricing, and policy resolve before they reach the model. Pairs with OpenAI Euphony for visual debugging. Works with Python, TypeScript, LangChain, LlamaIndex, n8n, MCP servers in Claude Desktop, Cursor, and VS Code, plus a Chrome extension.
Use cases, pricing, and trust
Production use cases include customer support with memory-powered personalization, EdTech tutoring, finance fraud detection, healthcare continuity, and voice agents. Free tier includes 5M tokens, with Starter, Accelerate, Supercharge, and Enterprise tiers. Company: XAlchemyst Technologies Pvt. Ltd., Kolkata, India. Contact founders@getalchemystai.com. See About, Contact, Privacy, sitemap, llms.txt, docs, and the OpenAPI spec at /openapi.json.
CLI, SDKs, and MCP for Alchemyst AI agents
Official Alchemyst AI CLI entry points: npm install @alchemystai/sdk (https://www.npmjs.com/package/@alchemystai/sdk) and pip install alchemystai (https://pypi.org/project/alchemystai/). Build the context-aware CLI agent in 10 minutes at https://getalchemystai.com/cli and the CLI Agent docs. MCP Streamable HTTP at https://getalchemystai.com/mcp. OpenAPI at https://getalchemystai.com/openapi.json. Developer portal at https://getalchemystai.com/developers with API keys, quickstart, and sandbox.
The model is replaceable.
Your institutional context isn't.
Models are commoditizing fast. Durable advantage comes from a context layer that operationalizes your business intelligence and stays yours no matter which model you run it on.
Models will keep changing. Your institutional context is the asset that compounds, so it should belong to you, not to whichever model you happen to run today.
Switch models freely. Keep your context sovereign.
Every model swap normally resets your agent's memory. Alchemyst decouples what your organization knows from whichever model reasons over it, so institutional context stays continuous across every upgrade or multi-model setup.
- Model-agnostic
- Context sovereignty
- Zero migration cost
- Multi-model routing
- Sub-300ms retrieval
Operationalize intelligence that runs your day-to-day.
This isn't a smarter chatbot. It's a context layer that turns what your organization knows into agents that run sales, support, ops, and research at scale: every decision traceable, every agent on the same source of truth.
- Run ops, not just answers
- One source of truth
- Every decision auditable
- Scales without FDE teams
One sovereign context layer, any model, agents that operate
A context layer that keeps your AI current, traceable, and semantically consistent.
One API call. Context arithmetic over your institutional knowledge graph. Every decision traceable back to its source, without managing a single vector database or graph store.
Context Arithmetic: the core primitive
Context arithmetic is the foundational primitive: dynamic set algebra over meaning, computed at query time. Instead of naïve top-K similarity, Alchemyst intersects to narrow scope, unions to widen recall, subtracts superseded or out-of-scope content, and ranks what remains, so only the right context survives into the window.
// Set algebra over meaning, at query timeconst window = alchemyst.context.search({ query: userMessage, groupName: ["sales", "emea"], // ∩ narrow scope metadata: { version: "v2" }, // ∩ filter});// − superseded / deduped → rank → top-KInstitutional knowledge graph + context traces
What you store is an institutional knowledge graph of your organization's context, fully traceable. Memory isn't three hard-coded layers. By applying context arithmetic over the graph you can derive the behaviors people expect from memory: recall what happened, resolve what it means, and inform how to act. The memory types are outcomes of the primitive, not separate modules.
// One graph + arithmetic → derived "memories"const captureTime1 = "end-date-" + Date.now();// Represents what should be added when your session is first saved.const storeInformationOfSessionAtFirstInstance = await ctx.add({ documents: [ ], metadata: { groupName: [session_id, captureTime1] }});// Now resume from where you left off, or let someone resume from there.const whatHappened = await ctx.search({ query: term, metadata { groupName: [session_id, captureTime1] }});// Second checkpintconst storeInformationOfSessionAtSecondInstance = await ctx.add({ documents: [...], metadata: { groupName: [session_id, captureTime2] }});// Now team lead / CXO looks up about the informationconst whatItMeans = ctx.search({ query: term, metadata: { groupName: [session_id] }})// "how to act" falls out of scope over the global contextContext Traces for full auditability
Every agent decision is traceable back to the exact context it had, at a query level. Not a summary, but the exact data points, scores, and rules that went into the model's context window. Debug in minutes, not days.
const trace = await alchemyst.trace.get( session_id, turn_id);// Returns: sources[], scores[], rules_applied[]// Pairs with Euphony for visual debuggingSemantic consensus enforcement
Define canonical term definitions at the org level. When "revenue" means different things to different teams, Alchemyst resolves the ambiguity before it reaches the model.
const gtmTeamResponse = await alchemyst.context.add({ documents: [...], // Data here metadata: { groupName: ["gtm", "revenue"] // The term "revenue" defined by GTM team }})const financeTeamResponse = await alchemyst.context.add({ documents: [...], // Data here metadata: { groupName: ["finance", "revenue"] // The term "revenue" defined by Finances team. }})const cxoResponse = await alchemyst.context.search({ query: "What's the revenue for Q2 2026?", metadata: { groupName: ["revenue"] // The term "revenue" defined for CXO, with clear segregation between the resources by GTM team and Finances team. }}) Illustrative · accuracy vs conversation context
Example Use Case
How do you debug what an agent can't see? Context Tracing with OpenAI Euphony
Pairing Alchemyst's Context Traces with Euphony, OpenAI's open-source conversation visualizer, creates an end-to-end debugging workflow. Every agent failure is now diagnosable in minutes: was it a retrieval problem, a configuration problem, or a model problem?
Give your AI agents the memory they deserve.
Join developers building the next generation of AI products with persistent, auditable context. Free tier available. No credit card required.
- Free tier
- REST + Python & Node SDKs
- 99.9% uptime SLA
- SOC 2 in progress