BanditDB is the decision layer for AI agents and adaptive applications.
It learns from context, action and reward, so every decision is a little better than the last.
Is it right for you?
BanditDB pays off on repeated choices with a score at the end.
| Domainwhere it’s used | Contextwhat it knows | Actionwhat it decides | Rewardhow it’s scored |
|---|---|---|---|
| Insurance | claim complexity, prior history, policy tier | route to fast-track, adjuster, or SIU review | time to resolution |
| Ad tech | device, time of day, audience segment | which creative variant to serve | click or conversion |
| Logistics | order size, zone congestion, SKU mix | pick path or packing station | fulfillment time |
| LLM routing | prompt embedding, task type | which model handles the request | task success, cost-adjusted |
| Checkout | cart value, returning visitor, device | discount, free shipping, or gift | completed purchase |
| Banking | credit utilization, income, repayment history | credit line offer to extend | repaid without default |
| Healthcare | symptoms, vitals, treatment history | which protocol to recommend | patient outcome improved |
| Edtech | skill level, past attempts, learning pace | which exercise or hint to serve next | concept mastered |
Where it sits in your stack
Stores facts and transactions as rows.
Retrieves related information by nearest neighbour.
Learns from decisions and their outcomes, one prediction-action-reward tuple at a time.
your app / agents
│
├── SQL ─────────────► postgres "what is true?"
├── embed + ANN ─────► vector store "what is similar?"
└── predict/reward ──► banditdb "what should I do?"
The whole API, nearly
Name the decision and its options.
Send the context, get the best action.
Report the outcome, even days later.
from banditdb import Client db = Client("http://localhost:8080", api_key="your-secret-key") db.create_campaign( "checkout", arms=["discount", "free_shipping", "gift"], feature_dim=4, ) context = [0.8, 0.2, 1.0, 0.4] arm, iid = db.predict("checkout", context) db.reward(iid, 1.0)
import { BanditDBClient } from "banditdb-js"; const db = new BanditDBClient({ url: "http://localhost:8080", apiKey: "your-secret-key" }); await db.createCampaign("checkout", { arms: ["discount", "free_shipping", "gift"], feature_dim: 4, }); const context = [0.8, 0.2, 1.0, 0.4]; const { arm_id, interaction_id } = await db.predict("checkout", context); await db.reward(interaction_id, 1.0);
curl -X POST http://localhost:8080/campaign \ -H "Content-Type: application/json" \ -d '{ "campaign_id": "checkout_offer", "arms": ["discount", "free_shipping", "gift"], "feature_dim": 4 }'
# make BanditDB a native tool in Claude, Cursor, or any MCP host claude mcp add banditdb banditdb-mcp \ --env BANDITDB_URL=http://localhost:8080 # your agent can now define its own decisions: # create_campaign("checkout_offer", # arms=["discount", "free_shipping", "gift"], # feature_dim=4)
Budgets and costs
Tell BanditDB what each option costs and how much you can spend. It spreads the budget across the whole period and puts each dollar where it brings the most return.
A search click costs $1.20, a social click $0.60, an AI ad $2.50.
For example, $5,000 a day. You can set several budgets at once, like total spend plus a cap for one channel.
Each dollar gets a price that rises when spend runs fast. A channel wins only if its return beats that price.
"pacing": {
"resources": [{
"name": "ad_spend",
"budget": 5000,
"horizon": 20000,
"arm_costs": {
"search": 1.20,
"social": 0.60,
"ai_ads": 2.50
}
}]
}
Example figures
Storage model · constant memory
It doesn’t store records. It stores beliefs.
Every interaction shrinks the uncertainty around what works. The model updates in place, so memory stays flat no matter how much traffic the database has seen.
For data scientists
Markets drift and audiences change. Set a half-life and the model’s confidence halves on that clock, so it tests again instead of trusting stale wins. Its best guesses are kept.
decay_half_life_hours: 24 · 168 weekly · 720 monthly
At every checkpoint, each completed decision is written to Parquet per campaign: what it saw, what it chose, what happened, and the probability it had of choosing it.
Logged propensities make off-policy evaluation (IPS, SNIPS) possible. List files with GET /export.
A bandit’s own scores are biased by who it chose to show each option to. Run the bundled causal-forest analysis on the export to separate real effect from selection.
python causal_analysis.py --parquet exports/checkout.parquet
Small binary, fast loop
Single binary
Per update
Predictions / sec
Lift on MovieLens
Algorithms
Monitoring · backup · restore
Prometheus metrics and per-campaign health. It warns you when a campaign stops exploring.
Every reward is on disk before the API answers. If the server dies a moment later, the reward is still there.
After a crash it rebuilds itself from disk. Nothing it confirmed is lost.
Model Context Protocol
The MCP server exposes campaigns as tools, so every agent in the fleet reads and writes one shared, persistent policy. Every recorded outcome sharpens the policy the whole fleet reads from.
claude mcp add banditdb banditdb-mcp --env BANDITDB_URL=http://localhost:8080create_campaignDefine a new decisionget_intuitionAsk which action to takerecord_outcomeReport success or failurecampaign_diagnosticsInspect learning stateRunnable examples
Cloud or self-host
Start in BanditDB Cloud, now in beta. Or self-host with one command.
curl -fsSL https://raw.githubusercontent.com/dynamicpricing-ai/banditdb/main/scripts/install.sh | shdocker run -d -p 8080:8080 simeonlukov/banditdb:latest