Full-stack A/B tests, delivered as pull requests.
Trevo studies your site, funnel, codebase, and past experiments to find opportunities your team may have missed. Then it writes the strongest ideas as full-stack variants and opens review-ready pull requests.
Read-only on main · PRs on trevo/* only · no card
exp: quote tax before the payment step
>_ Repo analysis
Your experiment backlog needs better ideas — and more engineering time.
Most teams face both problems. They don’t have enough high-confidence experiments to run, and the promising ideas they do have sit behind product work in the engineering queue. Trevo handles both: it finds experiments grounded in how your product actually works, then writes the production code required to launch them.
Find what to test. Get the pull request.
Trevo traces friction from the user experience into the underlying code. You approve the experiment; Trevo writes the diff.
+ The difference
Test the product,
not just the paint.
Trevo traces friction from the user experience into the underlying code. That means its ideas can go beyond button copy to pricing logic, API handlers, onboarding flows, recommendations, and prompts.
API & business logic
Split traffic inside the handler. Different fulfillment rules, different retry policy, different queue — scored against revenue, not clicks.
if (trevo.getVariant('tax-before-pay', identity) === 'quote-first')Pricing & packaging
Test the price, the tier boundary, the trial length. The variant is a value returned by your pricing service, not an overlay that flashes after paint.
order = trevo.getVariant('annual-anchor', identity)Prompts & models
Swap the model, tighten the prompt, cap the tool budget. Trevo ties each variant to downstream conversion and cost per resolved session.
model = trevo.get_variant("assistant-model", user_id=user.id)Ranking & search
Change the scoring function or the recall step and watch add-to-cart move. This code has never been reachable by a front-end optimizer.
if trevo.get_variant("rank-v3", user_id=user.id) == "hybrid":Flow & onboarding logic
Reorder steps, drop a gate, defer verification to day two. Redirect tests without the redirect — the server just renders the branch.
const steps = trevo.getVariant('onboarding-order', identity)And the front end, still
Copy, layout, components, whole page rewrites. Rendered server-side inside your own components, so there’s no flash of the control.
<Hero variant={useExperiment('hero')} />∴ The loop
From hypothesis to cleanup, you own every step.
Trevo is an agent with commit access to a branch — never to main. Your existing review process is the only gate, and it stays exactly where it is.
Connect the repo and the metrics
The Trevo GitHub App reads your code and writes only to trevo/* branches. Metrics come from the Trevo SDK — or your PostHog project, pulled straight in. Trevo maps routes, server logic, pricing paths and the events that mean money. Missing an event? Name it — the agent finds where that moment happens in your code and wires the tracking call itself, as a PR you review.
It opens a pull request
The hypothesis is the PR description. The variant is real code behind a Trevo flag, with the test file included. Not a config blob in someone else’s dashboard — a branch you can check out.
You review and merge — normally
CODEOWNERS applies. CI applies. Your branch protection applies. Nothing reaches production that your pipeline didn’t approve, and nothing runs from a script tag you don’t control.
Sequential stats call it, then it cleans up
mSPRT with always-valid p-values, so you can look whenever you want without burning the result. When a winner is called, Trevo opens a second PR that promotes it and deletes the loser and the flag.
► Watch a real run
Thirty-three minutes, replayed.
A fresh store, a fresh workspace, no rehearsal. These are the actual timestamps from a first setup — connect to first proposal in fourteen minutes, approval to open PR in two and a half.
Hover to pause · click any stage to jump.
Stages one to four are the run’s real artifacts; the results stage shows what a called experiment looks like.
terra-and-twine · Next.js storefront
exp: cart reassurance page
− Where the others stop
The honest comparison.
Categories, not vendors. If your experiment can be expressed as a CSS selector, plenty of tools will do it. If it can’t, this is the row that matters.
| Trevo | Visual A/B tools | Front-end AI optimizers | Roll your own | |
|---|---|---|---|---|
| What can change | Any code path — handler, price, prompt, query | DOM text, styles, images | DOM, copy and layout, generated | Anything, once you build it |
| Where the variant runs | Server-side or client, your call. No flicker. | Client-side, after paint | Client-side, after paint | Wherever you wire it |
| Who writes the variant | Trevo, as a pull request | You, in a WYSIWYG editor | The agent — front end only | Your engineers |
| Review path | GitHub PR · CI · CODEOWNERS | Vendor dashboard | Vendor dashboard | Pull request |
| Where winning code ends up | Merged into your repo | A vendor script tag, forever | A vendor script tag, forever | Your repo |
| Losing variants | Automatic cleanup PR | Accumulate as overrides | Accumulate as overrides | Manual, and usually skipped |
| Statistics | mSPRT, always-valid — peek anytime | Fixed horizon, peeking inflates error | Fixed horizon | Whatever you implement |
| Time to first test | Under 30 minutes | Days | Hours | A quarter, honestly |
σ Statistics
Look at the results whenever you want.
Fixed-horizon t-tests punish you for checking early — every peek inflates your false positive rate, which is why every experimentation deck has a slide begging people not to look. Trevo runs a mixture sequential probability ratio test instead. The p-value is valid at every moment it is computed.
- ✓Always-valid p-values. Stop the moment significance is reached, or don’t. The guarantee holds either way.
- ✓Priority follows the class of bet. Server-side decisions rank above section rewrites, which rank above copy tweaks — scored within a class, never across it.
- ✓Guardrail metrics are first-class. When a guardrail breaches, the experiment auto-pauses on its own — no one has to be watching.
- ✓Every decision leaves a trail. Approvals, calls and cleanups land in an append-only audit log.
+ The SDK
One primitive: a branch you can measure.
Assignment is deterministic and sticky, resolved in your own code from a synced snapshot. No network call in the hot path, no blocking script.
import { createClient } from '@trevosdk/node' const trevo = createClient({ secretKey: process.env.TREVO_SECRET_KEY }) export async function POST(req: Request) { const identity = { anonymousId: req.cookies.trevo_id } // sticky per visitor // the experiment is a branch in your handler, not a CSS selector if (trevo.getVariant('tax-before-pay', identity) === 'quote-first') { const quote = await tax.quote(cart) // variant: quote up front return json({ ...cart, tax: quote, step: 'review' }) } return json(cart) // control, untouched }
• Access & trust
An agent with a branch, not the keys.
Trevo has exactly the permissions a contractor on their first day would get, and every action it takes leaves a commit with its name on it.
- ✓Read-only on main. Write access is scoped to
trevo/*branches. Branch protection does the rest. - ✓Your data stays yours. Nothing in your repo or your metrics trains a model, ours or anyone else’s.
- ✓Variants resolve in your own code. Assignment runs locally from a synced snapshot — no blocking script, no third-party tag in your critical path.
- ✓An append-only audit log records every experiment decision and who approved it.
? Questions & trust
The questions your engineers will ask.
Short, honest answers on what Trevo sees, what it keeps, and what stays yours. The whole picture is in the guide.
Do you own or keep a copy of our code?
No. Your code stays yours — connecting a repo gives Trevo no ownership of it and no license beyond writing the pull requests you approve. Trevo never stores a copy of your source. When it writes a variant it clones your repository into a temporary workspace that is deleted the moment the job finishes. The only thing it keeps is a structural map of your app — a list of routes, components, and server-side logic with file paths and short descriptions — so it knows where a change would go. That map lives in your workspace alone and is deleted when you disconnect.
What exactly can Trevo see?
What a new teammate opening your repository could see, and nothing more: the files in the repositories you choose to connect, read through a GitHub App you install and can revoke at any time. It has read access to your default branch and write access only to trevo/* branches — it cannot push to main, and your own branch protection enforces that too. Every change it makes lands as a commit with its name on it, and an append-only audit log records who approved what.
Do you train an AI model on our code or our metrics?
No — nothing in your repository or your experiment metrics is used to train models, ours or anyone else's. When Trevo drafts a variant it sends a model only the slice of your repo needed for that specific change, and only to produce that one pull request. We rely on a small set of third-party model and infrastructure providers to run the scan and draft PRs, and we're happy to share that list on request.
How do experiments ship — could Trevo break production?
Trevo never deploys and never merges. It opens a pull request; your engineers review and merge it exactly like any other PR, through your existing CI and checks. Variant assignment then runs inside your own code from a synced config snapshot — there is no blocking third-party script in your critical path. Starting an experiment only flips traffic on code you already merged, and if you do not like a variant you simply close the PR and nothing changes.
What happens to our data if we disconnect?
Disconnecting the repository or uninstalling the GitHub App immediately invalidates Trevo's access and deletes the structural maps it built. Deleting your workspace purges the rest of your data, including any stored payloads, from our systems. You can do either yourself, at any time, without contacting us.
$ Pricing
Your first five experiments are free. Pay when you run a program.
Reading your repo, proposing experiments, and tracking your users costs us little, so it costs you nothing — and every signup gets five real experiments shipped end to end, no card required. Paid plans start where the sixth PR starts.
Free
Run the whole loop — scan to shipped experiments.
- ✓5 experiments to start — end to end, PRs written, monitored, cleaned up
- ✓Full repo scan & funnel map
- ✓25k monthly users · 3 team members
- ✓One repo, one workspace
- —One-time credits — no monthly refresh
- —One experiment live at a time
- —Proposals capped at 8
Out of credits? Add a card — $119 per experiment PR, or move to Starter.
Start freeStarter
A steady experiment cadence for one product.
- ✓First 5 PRs free, then 3 new experiments every month — unmerged PRs don’t count
- ✓Unlimited proposals — argue as many ideas as you want
- ✓2 experiments live at once
- ✓Full stack in one repo — server code included, not just the DOM
- ✓50k monthly users · 5 team members
- ✓PostHog integration · email support
Never blocked: overage at $99 per extra PR, $29 per extra seat.
Get startedGrowth
Experimentation as a program, not a project.
- ✓10 experiments every month · 5 live at once
- ✓2 context repos — proposals that reason across your stack
- ✓250k monthly users · 15 team members
- ✓Roles & an append-only audit log
- ✓Slack support
Never blocked: overage at $89 per extra PR, $25 per extra seat.
Get startedEnterprise
The whole org, every service, at your traffic. This is where Trevo replaces a team, not a tool.
- ✓Unlimited experiment PRs, live experiments & traffic
- ✓Unlimited context repos — full-stack reasoning across every service
- ✓Unlimited workspaces, products & team members
- ✓Priority model capacity · SLA · dedicated engineer
- ✓Security review, custom data terms, annual invoicing
>_ Get started
Turn missed opportunities into shipped experiments.
Connect the repo and the first proposals arrive in under fifteen minutes. Approve one and get back a pull request your team can review and merge.
First 5 experiments free · no card · no sales call · or talk to an engineer