IDEs
MCP tools for recall before a task and store after, without changing the flow teams already use.
Overview
What you get
TraceBase captures every solved problem as a reasoning trace and feeds it back into future runs. Your agents don't just execute — they accumulate expertise. Every run is built on every run before it.
SDK
Wrap OpenAI or Anthropic clients once; middleware runs recall, then your completion, then store.
Repeated work
Similar incidents surface prior traces instead of forcing the model to reason from zero each time.
Storage
Local SQLite by default, with optional embeddings when you want broader semantic retrieval.
TraceBase is included in the Daytona Startup Grid — Daytona's program backing early teams that ship AI-native developer infrastructure.
Before / After
Same model.
Different run profile.
TraceBase does not change the model choice. It changes what the model starts with and what the next run gets back after a fix has already shipped.
Same model, no layer
Cold path steps
Cold path every time
No recall path means every repeat case still pays for fresh exploration. The model can solve it, but it does not start from what already worked.
No prior context is injected before the call.
With TraceBase
TraceBase flow steps
Priors before the answer
Recall surfaces strong matches before tokens hit the model, then successful runs are written back so the next repeat case starts grounded instead of blank.
Benchmarks and methodology in the whitepaper.
How it works
Recall before the call.
Store after the fix.
The middleware sits between your code and the LLM. Before each call it checks memory. After each call it stores the result. No manual work.
01
Recall
Check memory for similar problems solved before.
02
Inject
Add prior solution to system prompt as a hint.
03
Call
LLM solves faster with context. Fewer tokens.
04
Store
New trace captured. Memory grows automatically.
Integrations
Works with any agent.
Fits the tools teams already use.
MCP for IDE-native agents, middleware for wrapped SDKs, and a clean path for custom runtimes when retrieval needs to stay under your control.
Claude Code
Cursor
Codex
Under the hood
Multi-signal ranking
Fingerprint, BM25, Jaccard, structural, cosine. Two-stage retrieval.
Adaptive weights
Thompson Sampling learns optimal signal weights from your feedback.
Recall-before-call
Middleware recalls and injects prior solutions automatically.
Streaming
Full stream:true support. Traces captured after stream completes.
Local-first
SQLite with WAL. Sub-millisecond recall. Data stays on your machine.
Embeddings
Optional cosine similarity via OpenAI text-embedding-3-small.
Setup
Three ways.
To use TraceBase.
Pick the layer that fits your stack: wrapped SDKs, one-command IDE rollout, or direct control inside custom agents.
OpenAI / Anthropic
recallinjectcallstore
SDK Middleware
Wrap the client once and let recall run before each call while store captures the resolved path after completion.
agent.ts
const layer = new ReasoningLayer() const openai = wrapOpenAI(new OpenAI(), layer) await openai.chat.completions.create(...)
Custom integrations
Need TraceBase inside a custom runtime?
When your models already sit inside a larger workflow, the right move is usually not another generic widget. It's a reasoning layer shaped around the way your pipeline actually behaves.
We can plug retrieval, injection, and memory capture into existing agent loops, internal tools, or product surfaces without forcing a rewrite.
01
We map your current pipeline
We identify where your agents repeat work, where prompts drift, and where cost spikes come from avoidable re-exploration.
02
We fit TraceBase into the stack
SDK middleware, MCP tools, or a custom orchestration layer — whatever matches the way your product already routes model calls.
03
Your system compounds from there
Resolved paths get stored, recall quality improves, and repeat workflows start grounded instead of blank.
Pricing
Open source now.
Managed launch pricing.
Self-hosted is available today. The startup and enterprise tiers below are planned managed rollout packaging, shown here as draft launch pricing rather than live checkout.
Choose billing cadence
Annual keeps pricing a little lower for teams committing to a production rollout.
Open Source
Available now
$0/mo
Self-hosted memory, MCP, SDK middleware, and local SQLite storage.
- Local SQLite memory
- MCP / HTTP / SDK access
- Adaptive weight learning
- Embeddings with your own API key
Startup
Managed tier
$159/mo
Managed traces, analytics, and team access for small product teams shipping weekly.
- 50,000 injections / mo
- Unlimited API keys
- Unlimited team members
- Hosted traces + analytics
Enterprise
Custom rollout
Custom
Private deployment, SSO, and support for higher-volume or regulated environments.
- Unlimited injections
- SSO + SAML
- Private deployment options
- Custom retention + support
Stop paying for the same reasoning twice.
One install. Agents that get better with every run.