AI-Native Experimentation
Engineering for uncertainty.
Describe what you're showing your users and what a good outcome looks like. Curious writes alternatives, tests them in live traffic, and learns what works for whom.
The problem
Experimentation tools give your team more work.
Most optimization software works like this: you buy a platform, then your team writes the hypotheses, designs the variants, configures the experiments, waits for statistical significance, reads the dashboards, and decides what to ship. The software makes the work possible. Your people still do it. It comes out of the software budget and it costs your team's time on top.
That's fine for the handful of decisions important enough to justify the effort. But your product has thousands of decisions baked into it: headlines, upgrade prompts, onboarding emails, pricing, the copy on every button and every page. Nobody is running experiments on those. The tools are too heavy and the team has other things to do. So those decisions stay as guesses.
Your experimentation platform tells you which variant won. Curious finds the winner for you, then keeps looking.
The solution
You're not buying a tool. You're buying the outcome.
Curious does the work. You describe what you want to optimize and what a good outcome looks like, and the system handles everything else: generating the alternatives, running the experiments, learning what works for each user. There's no dashboard to check and no experiment to design. You're paying for optimized content, not access to a platform.
You stay in control. Dashboards show everything the system is doing and why, and approval workflows mean nothing reaches your users without your sign-off, until you decide it doesn't need one. How you stay in control
The budget it replaces isn't a SaaS license. It's the copywriter, the growth marketer, the agency retainer, the consultant who comes in once a quarter to review your pricing.
Why it works
AI can generate a good starting point for almost any decision. It's read enough about what converts to give you something better than a guess. But it's capable enough to sound right about almost anything, and unreliable in exactly the ways that are hard to catch. It takes shortcuts, it has blind spots, it tells you what you want to hear, and it doesn't question what it might be missing.
AI is smart, but lazy.
Curious doesn't ship the AI's first answer. It generates a set of candidates, each built on a different hypothesis about why it might work, and tests them against your actual users through a contextual bandit. The model's predictions set the starting point so the system is useful from the first request. As data comes in, traffic shifts toward what's performing, and the system keeps generating new candidates to test. It never declares a winner and stops.
Starts informed.
The model's predictions about what will work become the system's starting assumptions. You get useful results from the first visitors, not after ten thousand.
Personalized per user.
A contextual bandit doesn't just find the best variant overall. It learns which version works for which type of person, based on their plan, their device, their history, and whatever context you pass.
Learns from early signals.
A purchase takes days to observe and churn takes months. Curious learns from the clicks and sessions that arrive in minutes, then confirms against the real outcome when it lands.
Optimizes for what you care about.
You define the goal. A purchase counts as a win. A refund counts against. You set hard limits on things like support tickets or churn that the system can't exceed.
Never stops.
There's no winner to declare. Curious concludes experiments and starts the next ones while you sleep, and keeps generating new candidates as your product and your audience change.
No LLM in the serving path.
AI generates and analyzes offline. The /decide call itself is pre-fitted math, built to answer in tens of milliseconds, so optimization never slows your product.
The model dividend
In a workflow tool, a better model writes better suggestions for the same human bottleneck. In Curious, a better model starts improving every surface you've handed it, the day it ships.
The API
Every call is a complete declaration.
A single call to /decide describes the entire optimization problem. You specify the element (an upgrade prompt, a landing page headline, an onboarding email), the content you're showing now, what you're optimizing for (purchases minus refunds, subject to a cap on support tickets), and context about the user: their plan, their device, what page they're on. Curious returns the content it predicts will work best for that person, and updates its model based on what they do next.
{
"element_name": "upgrade_prompt",
"controls": [{ "content": { "headline": "Upgrade today" },
"hypothesis": "Direct and to the point" }],
"rewards": [{ "name": "purchased", "weight": 1.0 },
{ "name": "refunded", "weight": -0.5 }],
"constraints":[{ "name": "support_ticket_created", "threshold": 0.10, "bound": "upper" }],
"context": { "plan": "pro", "device": "mobile", "page": "/pricing" }
}{
"decision_id": "dec_7g2kq9",
"content": { "headline": "Don't lose your 47 saved templates." },
"hypothesis": "Loss aversion beats generic urgency for long-tenured users"
}You sent "Upgrade today" as the baseline. Curious returned "Don't lose your 47 saved templates" for a pro user on your pricing page. That line exists because it outperformed every other candidate the system generated and tested.
The API is agent-native: an MCP server exposes the same control plane, so your AI tools can read experiments and submit variant ideas without leaving the conversation.
Learning is the new frontier.
Stop shipping guesses. Start today.
Every experiment feeds one counter: what Curious earned beyond your control, in your own units.