Build agents.
Ship fast.
Console gives engineering teams everything needed to build, deploy, and operate production-grade AI agents — BYOK, multi-LLM routing, tool registry, environments, tracing, and cost attribution in one gateway.
6
Developer modules
BYOK
Any model provider
Full
Lifecycle coverage
// six modules
Six modules.
One developer gateway.
Each module is independently useful and composable. Together they cover the full lifecycle of building, shipping, and operating production AI agents.
BYOK & Multi-LLM Routing
Connect your own API keys from any provider — OpenAI, Anthropic, Google Gemini, Mistral, or a private model endpoint. Console handles key rotation, rate-limit management, and automatic routing. Swap models without touching agent code.
- Route by latency, cost cap, or capability requirement
- Automatic fallback when a provider is degraded
- BYOK — your keys, your data, zero vendor lock-in
- Usage metered per key per environment
API Keys & Model Routing
alchemi console · keys · routing
claude-3.5-sonnet
BYOK ****1a4f
428ms
$0.009/run
gpt-4o
BYOK ****8e2c
612ms
$0.014/run
gpt-4o-mini
BYOK ****8e2c
198ms
$0.002/run
gemini-2.0-flash
BYOK ****c9b1
310ms
$0.003/run
MCP & OpenAPI Tool Registry
Publish any internal API, SaaS integration, or database to the shared tool registry via MCP or OpenAPI spec. Every agent in the org can discover and call tools without engineering a custom integration each time.
- Single registration, available to all agents across all teams
- Versioned registry — roll back tool specs without redeployment
- Health checks and status monitoring per tool
- Access controls per team, agent, and environment
Tool Registry
alchemi console · tools · registry
Isolated Dev / Staging / Prod
Promote agents through environments with full isolation. Each environment carries its own model config, API keys, budget, and access policies — ensuring no staging agent can touch production data, costs, or keys.
- One-command environment promotion: dev → staging → prod
- Per-environment budget caps enforce cost boundaries
- Environment-level model substitution without code changes
- Locked production environments prevent accidental changes
Environment Manager
alchemi console · environments
Model
gpt-4o-mini
Budget
$50/mo
Agents
4 deployed
Tool Registry
test registry
Trace Replay & Debugging
Every agent run generates a structured trace capturing every LLM call, tool invocation, token count, and latency. Replay any run locally in milliseconds — no production reproduction needed. Compare traces across model versions to pinpoint regressions.
- Full span trace: LLM calls, tool calls, latency, token counts
- Replay any historical run without touching production
- Side-by-side trace comparison across model versions
- Failure root cause visible in the trace, not buried in logs
Trace Replay · run #8a2f
alchemi console · traces · replay
Streaming & Embeddings API
Console exposes a streaming-first API that works as a drop-in OpenAI replacement. First-class streaming across every connected model, plus a managed embeddings API with built-in vector storage — no separate infrastructure required.
- Streaming responses across all connected providers
- OpenAI-compatible API — works with existing SDKs, zero migration
- Built-in embeddings endpoint with managed vector store
- Live req/min monitoring with P99 latency and error-rate tracking
API Dashboard
alchemi console · api · usage
Req / min
530
P99 latency
410ms
Error rate
0.01%
Requests / min · last 8 samples
Endpoints
Cost Attribution per Run
Every agent run is tagged with team, agent name, environment, and user ID. Cost attribution is exact and immediate — not estimated at month-end. Set budget caps per environment to prevent runaway spend before it happens.
- Per-run cost breakdown: tokens × model price, exact
- Tagged by team, agent, environment, and user
- Budget caps enforce spend limits per environment
- Compare cost across model versions before promoting to prod
Cost Attribution
alchemi console · cost · per-run breakdown
Today total
$12.48
This month
$248.30
Runs today
1,308
pipeline-bot
Sales · prod · 2,051 tok · 1.42s
churn-bot
Sales · prod · 1,840 tok · 0.89s
finance-bot
Finance · prod · 20 tok · 0.02s
lead-scorer
Marketing · staging · 3,210 tok · 2.1s
// onboarding tour
From keys to prod
in four commands.
Console is designed for engineers who ship fast. Here is how teams go from zero to production-grade agentic AI.
$ alchemi keys add --provider=openai
Connect your API keys — OpenAI, Anthropic, Google Gemini, or a private model endpoint. Console handles key rotation, rate limiting, and routing automatically. BYOK means you own your data.
$ alchemi tools register --spec=openapi.yaml
Register your tools via MCP or OpenAPI spec. Your internal APIs, SaaS integrations, and databases are published to the shared tool registry. Every agent in the org can discover and call them.
$ alchemi env create staging --from=dev
Promote your agent to a new environment with one command. Each environment has isolated model config, secrets, budgets, and access policies. Ship to prod only after staging passes.
$ alchemi trace --run=8a2f --replay
Every agent run produces a full trace: every LLM call, every tool invocation, every token, every millisecond. Replay any run locally without reproducing it in production. Debug in minutes, not days.
// use cases
Where each module fits.
Real-world scenarios where engineering teams reach for each Console module.
Multi-model production pipeline
Route task types to different models: GPT-4o for reasoning, Claude for long-context synthesis, Gemini for structured extraction — from a single Console API with automatic failover on provider outage.
- Model routing by task type or latency SLA
- Automatic failover on provider downtime
- Per-model cost attribution in real time
Shared tooling for 50 engineering teams
Platform team registers your Salesforce, Postgres, and Slack integrations once. Every agent built by any team can discover and call them without filing a platform ticket or maintaining a custom integration.
- One registration, used org-wide
- Versioned specs — no breaking changes for consumers
- Centralized health monitoring per integration
Safe prod promotion with isolated staging
Agents graduate from dev → staging → prod. Each environment has its own model, keys, and budget. Production is locked — no accidental writes or cost overruns from staging test runs.
- One-command environment promotion
- Budget caps per env prevent cost bleed
- Locked prod gates prevent config drift
Debugging regressions after a model update
After upgrading to claude-3.5, three agents returned different formats. Engineers replay pre-upgrade runs against the new model, compare spans side-by-side, and find the exact prompt that changed behavior — in minutes.
- Replay historical runs against new model versions
- Span-level diff to isolate regression source
- No production reproduction required
Drop-in streaming for existing products
Product team wants streaming responses in the UI. Console's OpenAI-compatible streaming API slots in with zero SDK changes — same stream: true parameter, same response format, now routing across four providers.
- OpenAI-compatible — no SDK migration needed
- Streaming across all connected providers
- Built-in P99 latency and error-rate tracking
Chargeback model for business unit AI spend
Finance asks for AI spend split by team. Every Console run is tagged with team and agent. Engineering pulls a monthly export and has exact chargeback numbers — no custom billing infrastructure required.
- Per-run cost tagged by team and agent
- Budget caps enforce pre-approved monthly limits
- Export-ready cost breakdown for finance
// full capability list
Everything Console can do.
Connect your own keys or use AlchemiStudio's managed pool. Route by latency, cost, or capability. Supports OpenAI, Anthropic, Google, Mistral, and private endpoints.
Register any tool via MCP or OpenAPI spec. Shared, versioned tool registry across the org. Agents discover tools automatically.
Dev, staging, prod — each with own model config, secrets, budget, and access policy. One-command promotion between envs.
Full trace for every run: every LLM call, tool invocation, token, latency. Replay locally. Compare traces across model versions.
First-class streaming across all models. Built-in embeddings API with managed vector storage. Drop-in OpenAI replacement.
Every run tagged by team, user, agent, env. Exact per-run cost breakdown. Budget caps per env. No mystery bills.
// the platform
Console powers the whole platform.
The tool registry, model routing, and environments you manage in Console are what Copilot and Compute rely on. One gateway, four products.
Cockpit policies determine which models and tools are available in Console per team. Governance flows from Cockpit down.
See Cockpit →Business teams in Copilot access the same tools and models that engineers registered in Console — enterprise grade from day one.
See Copilot →Console agent runs are executed in Compute sandboxes — isolated, ephemeral, and destroyed after each run.
See Compute →