After Surpassing Gemini, Karpo Open-Sources Another Work: Browser Agent Delivers Both Speed and Efficiency

Wenting, from Aofeisi, QuantumBit | WeChat Official Account QbitAI
It's 2026, and a young team has actually gone out of its way to train a decision model—and on its first showing, it has left Gemini behind?!
In the same "City Scanner" challenge, Karpo picked out 10 good leisure and entertainment spots for me from 36 events (average spend under $50, commute distance only 5km) in just 2.6 seconds, while Gemini 3.5 Flash took a full 14.96 seconds.
Nearly 6 times faster! And not a single filtering condition was missed, with 100% accuracy across all 36 questions.
This newly emerged decision-making master is Karpo Decision 31B, just open-sourced by MachinePulse AI.

It is purpose-built to give Agents high-frequency, low-latency decision-making capability, making every judgment faster and cheaper.
For example, which button to click next when browsing a web page, whether a task is complete, which of dozens of candidate tools best meets the requirements—it can directly give a judgment, and works quite nimbly.
A single RTX PRO 6000 is enough to put it on the job; faced with more than 140,000 requests on the public set, its median response time is only 94 milliseconds—not even enough time to blink.
On the Decision Index leaderboard, where a full 300 models compete, Karpo Decision 31B also took first place with a Full score of 73.9, able to judge up to 255 candidate options simultaneously for a single question, with calibration error reduced to 2.3%.

Going further, MachinePulse has also officially open-sourced to developers the browser operation framework already used in its own Personal Agent product Karpo!
This solution adopts a System 1 + System 2 architecture, including the karpo-browser framework, the Karpo Decision 27B Act model specially trained for web action decisions, and the accompanying web action decision benchmark KBB.
On the 102 core tasks of Browserbase Benchmark v2, this solution achieved an average success rate of 89%, an average time of 201 seconds, and a model cost of only $0.096 (about 0.64 yuan) per task.
Compared with the top-ranked Claude Fable 5.2 + Claude Code, it completes tasks about 1.9 times faster, and its model cost is only one-thirteenth of the other's.

We observed that when the success rate requirement is relaxed to 80%, but with a genuinely user-usable experience within 250 seconds and a cost within $0.15, none of the 91 records on the entire leaderboard achieved it—Karpo alone did, and by a large margin, truly achieving accuracy, speed, and low cost all at once! Karpo specifically notes in the table that it does not participate in the ranking, but its self-tested full set of 102 questions plus the stringent requirement of averaging 3 runs far exceeds the other models' requirement of running only 38 questions once.
This is exactly what every tech stack needs!

Goodness, this AI strategist that makes decisions on behalf of Agents—how much more can it do?
While You're Still Waiting for the Large Model to Reply, Karpo Has Already Finished the Job
Speaking of which, since Jev exploded overnight in September this year, the decision model track has leapfrogged into one of Silicon Valley's hottest star tracks.
In just 24 days, TypeSafe AI, the company behind Jev, landed a valuation of $7.5 billion (about 50 billion yuan).
For a time, tech giants such as OpenAI, Microsoft, Amazon, and Cloudflare all rushed into the arena, and the decision model track quickly became lively.
Why has everyone suddenly set their sights on this business?
As Agents become more capable, if every tool selection or result filtering requires calling a general-purpose large model to generate an answer word by word, it's a bit like using a sledgehammer to crack a nut.
Not only is it slow, but Tokens also burn away, and your wallet shrinks along with them.

Thus, decision models dedicated to handling these high-frequency, trivial judgments for Agents have found their place.
For example, the hit Jev and Google's newly launched Gemini Decision 1 can quickly give decision probabilities, but neither is open-sourced, making it hard for developers to deploy them themselves.
Decision models with open weights (such as GLiDE) do not necessarily max out both speed and judgment capability at the same time.
So Karpo Decision 31B took a few more steps forward: it doesn't need to write an essay on the spot; a single forward inference is enough to compute the probabilities of an entire set of options in an instant, and it is fully open-sourced.
Take "Ten Appetites, One Menu" that I tried out on Karpo's official website.
This is a food-ordering mini-game where a human and an AI compete on the same stage. Karpo Decision 31B and I need to order for 10 guests at the same time, catering to each one's budget, tastes, and dietary restrictions, while also seeing who serves faster and more accurately.

It looked simple, but who'd have thought—I had just moved the cursor to the first guest's requirements, hadn't even finished reading the first line, and Karpo Decision 31B had already, at a speed of 1.3 seconds, swiftly served all 10 dishes to the table.
And it didn't get a single one of the 10 guests' requirements wrong!
I was... utterly crushed?! No, no, steady, steady, it can't be that far off...
But when I finally finished reading the second guest's requirements and was about to continue choosing dishes, I glanced at the timer—a full 13 seconds had already passed.
Goodness, Karpo would have handed in its paper 10 rounds ago, and I was still stuck on the second question...
Now I got anxious. Starting from the third question, I simply quietly cheated: whatever it clicked, I clicked the same.
But even copying the answers, I still couldn't catch up.
In the end, I simply threw caution to the wind and clicked randomly, thinking maybe I'd get lucky.

But even after all that guessing and half-copying, I still spent a full 83.9 seconds to complete the entire task.

Meanwhile, let's look at the general-purpose large model side.
For the same 10 questions, I also sent screenshots to GPT-6.2 Astra (High tier) to do, and it took a full 34 seconds to get the answers.
In this comparison, Karpo is not only 64.5 times faster than me, a human player who had already secretly cheated, but also about 26 times faster than GPT!
And this kind of judgment work is even more useful when placed in developers' everyday Agent-building work.
Because developing an Agent that automatically handles GitHub Issues may involve a whole chain of judgments just to decide which tool to call, how to rank the retrieved code files, and whether the task is complete.
If every step requires calling a general-purpose large model and waiting for it to slowly generate an answer, not only is the workflow easily slowed down, but the Token bill also rises along with it.
Karpo, however, can put multiple judgments into a single request and directly return the probability of each candidate option, saving the overhead of generating answers word by word, giving Agents a chance to run faster and cheaper.

More critically, according to JevBench's GPU cost estimates, Karpo needs only about $0.025 (0.17 yuan) per 1,000 decisions—equivalent to spending just $1 (about 6.67 yuan) to let it run nearly 40,000 decisions!

Compared with routinely calling general-purpose large models, the cost simply plummets.
Moreover, Karpo has really brought this decision-making capability into the browser, greatly improving users' web task experience!
The MachinePulse team has newly open-sourced this browser Agent solution called karpo-browser, which innovatively adopts a System 1 + System 2 fast-and-slow dual-model division of labor, letting a general-purpose large model and a dedicated decision model work together.
System 2 does the thinking, System 1 does the doing.
For example, a user wants to book a restaurant.
The general-purpose large model DeepSeek V4.1 Flash is responsible for understanding the requirements, breaking down the task, and preparing the information to be filled in;
while Karpo Decision 27B Act, specially trained for web operations, is responsible for selecting input boxes and clicking buttons on the page, deciding which operation to execute next, with a median single-decision latency of only 931 milliseconds (0.93 seconds).
The karpo-browser framework behind it is responsible for reading the web page, executing operations, and handling page changes and execution exceptions.

And the effect of this division of labor is actually quite something.
Title: After Overtaking Gemini, Karpo's New Release Goes Open Source Again: A Win-Win for Browser Agents in Speed and Efficiency
The team ran three rounds of testing across all 102 tasks in Browserbase Benchmark v2 and found:
About 78% of operations on web pages were delegated to the Karpo decision model.
Yet these operations accounted for only 14% of the entire Agent's runtime and 13% of model cost.
As a result, web operations that previously required repeated calls to a general-purpose large model and word-by-word answer generation can now be handled quickly by the decision model, freeing up the large model to take charge of planning, verification, and more complex tasks.

And this time, MachinePulse has also opened up the entire development toolchain.
In addition to the Karpo Decision 27B Act model weights, there is the karpo-browser framework written in TypeScript.
This framework can flexibly adapt to different open-source large models and decision models.
Developers no longer need to build a browser Agent from scratch; through MCP, they can plug this browser operation capability into existing Agents such as Claude Code and Codex.
There is even a companion KBB (Karpo BrowserBench) web action decision benchmark, covering 584 real websites and 23,075 web operation steps. Through real web page recording and offline replay, developers can test whether the model chooses the right action at each step.
From model weights to the browser execution framework to the companion evaluation tools, developers can now truly install this System 1 + System 2 solution into their own Agents.

△Four deployment entry points
And the value it brings goes beyond saving on model call fees.
The MachinePlulse team says that compared with using expensive top-tier models, this solution, while maintaining excellent task success rates, has the potential to let developers support 5-30 times the original user scale with the same operating budget.
For developers who want to turn Agents into products truly aimed at a large number of users, this may be the more exciting part.
Picking projects fast and accurately, and good at reading between the lines too! Karpo has something going for it
Looks pretty good, so of course I had to roll it on the spot!
So I gave Karpo Decision 31B two questions, first to see whether it can filter technical materials quickly and accurately, and then to experience whether it can understand my sarcasm. (doge)

Test 1: With 8 technical search results in front of it, can Karpo quickly and accurately pick out the truly useful ones?
Suppose we are looking for an open-source browser Agent that supports local deployment and can proactively click, fill in forms, and navigate web pages.
I threw 8 technical search results at Karpo all at once. At first glance, every one seemed relevant, but mixed in were various tools that can only be viewed and not operated, Agents that can only run in the cloud, and projects that are fully featured but not open source.

Let's see whether it can pick out the projects that truly meet the requirements.
As a result, in just 308 milliseconds (about 0.3 seconds), Karpo accurately identified the four qualifying results: A, D, E, and G!
It did not miss any of the other four distractors mixed in either.
Test 2: With all my sarcasm, can Karpo hear the implied meaning?
However, making decisions is often not just about filtering results.
Chinese culture is broad and profound, and sometimes we cannot just trust the literal meaning. (doge)
Great, this Agent deleted all my files again, really a big help!
If you only focus on "great" in the first half of the sentence, or "a big help" in the second half, you will absolutely fail.
So I gave Karpo 6 tone judgment questions, ranging from straightforward praise to ironic complaints to neutral expressions mixing praise and criticism, to see whether it can read the subtext and to what degree.

In just 232 milliseconds (about 0.23 seconds), Karpo Decision 31B gave judgments for all 6 questions, uncovering all the complaints, praise, and complex emotions hidden between the lines.
It even grasped the fourth sentence, "The page loaded a bit slowly, but the results were accurate, overall it's okay," an evaluation that neither praises nor criticizes, with a mix of good and bad.
It even gave a subtle perception of 91% neutral probability, 8% approval, and a faint 0.2% dissatisfaction.
Not bad, finally didn't crash the online service today.
Even though the sentence starts with "Not bad," Karpo assigned a full 88% probability to a negative attitude, 10% to a positive attitude, and 2% to neutral or mixed praise and criticism.
So the resentment over past crash experiences hidden behind the affirmation of this task and this praise was also fully heard by it.

In developers' practical applications, this capability is actually very useful.
For example, a customer service Agent judging whether a user is truly satisfied, or a development tool analyzing user feedback, both need to identify the true attitude behind the literal expression and avoid mistaking complaints for praise.
Saying goodbye to word-by-word generation while also avoiding lopsided strengths: how was Karpo forged?
Seeing this, everyone is probably curious: how exactly does Karpo Decision 31B compress so many judgments into a single inference and still directly output probabilities?
One of the secrets lies in its specially designed Readout Head.
In the past, when a general-purpose large model faced a multiple-choice question, it often needed to generate the answer token by token, and then a program parsed the final option from the text.
Karpo simply skips this step.
It assigns dedicated encodings to candidate options, and then places a marker after each question for reading the result. After the model reads the input, the Readout Head scores each option at this position and converts the scores into probabilities.
The entire process requires only one forward inference, with no word-by-word answer generation, and the number of output tokens drops directly to 0.

△Readout Head mechanism
Moreover, this design can handle three different types of decisions at once.
For example, which tool should the Agent call next?
This can be handled by Choice (multiple-choice questions), letting Karpo distribute probabilities among up to 255 candidate options so the Agent knows which is more worth choosing.
If the Agent has been busy for a long time and needs to judge whether the task is actually complete?
Then leave it to Noul (Yes/No judgment questions), directly returning the probability that the task is complete.
As for how relevant the search results are, or how well a recommended item matches the user's taste, that can be left to Score (rating questions), letting the model give probabilities for different rating levels, which the system then uses to calculate scores and adjust ranking.
Three question types share the same Readout Head.

However, being able to answer one question at a time is not enough.
When an Agent really gets to work, it may need to filter dozens of search results and compare dozens of tools at the same time, with a large chunk of web page content or task context behind it.
Does that mean every time it judges a candidate, it has to recompute the same material?
Karpo does not want to do this kind of repetitive work.
So the team designed the Branch Attention mechanism.
It supports 256K context capability and splits the input into two parts. One is the Shared Block used by everyone, holding background materials such as task instructions, question lists, and web pages; the other is each question's own Branch, containing the corresponding question, options, and result-reading marker.
Shared content is computed only once, while each question can be answered separately without interfering with the others.

△Schematic diagram of the Branch Attention architecture
On a single RTX PRO 6000, for requests of 1K-4K tokens, Karpo's median time to answer a single question alone is only 371 milliseconds.
And when a single request contains 16-63 questions, the median time is only 653 milliseconds.
Dozens of judgments are pooled together, yet the time does not grow exponentially with the number of questions, so the cost for the Agent to handle high-frequency decisions has the chance to drop significantly.
For developers, this is very appealing.
However, being fast at judging also requires some self-awareness.
After all, whether the Agent automatically executes the next step or obediently hands the decision back to a human often depends on how confident the model is in itself.
If it clearly has only a 60% chance of winning but blithely says 99%, that is really a bit frighteningly confident. (doge)
To this end, Karpo also uses RLCD (reinforcement learning for calibrated decisions).

It not only rewards the model for choosing the right answer, but also calculates rewards based on the entire set of predicted probabilities, encouraging the model to truthfully report its confidence.
Even if the labels in the training data are disputed, it tries to preserve this uncertainty rather than forcibly collapsing it into a single answer.
On public JevBench questions, Karpo's expected calibration error (ECE) is only 2.3%.
In this way, developers can try setting different execution thresholds for the Agent, so that the Agent can act decisively while also knowing when to stop and hand things back to a human for review.
RSI enters the scene, and Karpo corrects the lopsided-training problem
After surpassing Gemini, Karpo's new release is open-sourced again: browser Agent achieves both speed and efficiency
However, with speed and probability both solved, Karpo still had to face another trickier problem.
That is, you must never end up over-specializing yourself during training.
After all, the decision-making needs an Agent encounters every day are wildly varied.
Today it helps you screen open-source projects, tomorrow it may need to judge whether code has security vulnerabilities, and the day after it has to vet a contract or procurement document.
If a model is only ever good at the kinds of problems it saw during training and falls apart the moment the scenario changes, that would be truly embarrassing.
And during training, the Karpo team did spot exactly this kind of warning sign.
As training progressed, the model's public test score rose from 73.1 to 75.1, but on evaluations across 13 unfamiliar domains, accuracy actually dropped from 72.1% to 70.7%.

To solve this problem, the Karpo team made generalization a training priority and introduced the RSI (Recursive Self-Improvement) training framework.

It first trains multiple candidate models, evaluates them one by one, and then, through Model Fusion, combines the strengths of different versions.
Only if the fused model beats the current model can it advance and enter the next round of iteration.
This time, the team selected 5 different Checkpoints, 3 from full-parameter fine-tuning and the other 2 from LoRA fine-tuning.
Through weight averaging, they combined the better generalization ability of the earlier models with the stronger specialization ability of the later models.
The results were quite good. After fusion, the public test score remained at 75.1, but accuracy in unfamiliar domains rose from 70.7% to 72.3%, a rebound of a full 1.6 percentage points.

Moreover, after fusion is complete, it is still a standard 31B-parameter model, with no increase in structure, parameter count, or inference overhead.
In the same 13-domain test organized by the team, Karpo ultimately achieved 72.3% accuracy, surpassing the previous top three on the Decision Index Full leaderboard: KnowLine 31B Gen1 (71.5%), Sieve 31B v3 (70.4%), and GLiDE 1.2 (69.1%).
It lost no points on public questions and actually performed better on unfamiliar ones.
For a decision model that wants to be embedded in various Agent workflows and take on different judgment tasks at any time, this well-rounded ability is probably more noteworthy than simply scoring a few more points.

Let the Agent hesitate less, and give developers more freedom
Anyway, after testing it out, what impressed me most was Karpo's crispness when handling those high-frequency small judgments.
Today, decision-making is becoming a layer of capability in AI systems that can be divided up independently.
As early as April this year, AWS CEO Matt Garman foresaw a similar trend in an interview with Stratechery:
In the future, various models will coexist. Some small models may even be able to do things that the latest OpenAI models still cannot do, and they will become smaller, cheaper, and faster.
Diogo, founder of Jev, expressed a similar judgment:
In the future, AI will not have to rely on large models to generate answers for everything. Fast decisions can be handed to specialized models, while complex reasoning is handled by other models, each doing its own job.
And the emergence of Karpo gives developers one more open-source option for realizing this approach.
When Karpo was released, LeahW summarized its design philosophy this way:
Choosing the next tool should not take a whole paragraph.
When judgments are fast enough and cheap enough, developers also have the opportunity to arrange more detailed screening and checks in an Agent's search, recommendation, and task-execution workflows, rather than relying on generative large models for everything.
What's more interesting is that even Karpo's name exudes a sense of ease.
It comes from the Latin Carpe Diem, meaning "seize the day, enjoy the moment."
And the MachinePulse team developing Karpo has long worked deeply in the Personal Agent direction, which happens to address those real yet trivial little dilemmas in our daily lives.
For example, what to drink today? How do you want to relax after work? What fun things are nearby this weekend?
Sometimes we only have a vague idea in our heads and cannot even clearly say what we want.
What Karpo wants to do is turn these vague ideas into concrete choices, helping people agonize a little less and get out earlier to enjoy life.
△When out and about, just double-tap the back of your phone to instantly summon Karpo to help us find nearby entertainment spots
For the developer community, Carpe Diem now seems to carry an additional layer of meaning.
Hand trivial decisions to Karpo, and save your precious time for what you truly want to do.
After all, isn't the point of technological progress to let us more freely do what we want to do?
Now, the MachinePulse team has simultaneously open-sourced six Karpo Decision full-size models: 0.8B, 2B, 4B, 9B, 12B, and 31B, so everyone can call them according to actual needs~
And this time, even Karpo Decision 27B Act, which specializes in web action decision-making, the browser Agent framework karpo-browser, and the accompanying evaluation set KBB have all been opened to developers as well.
From making decisions for Agents to letting Agents actually get to work, Karpo truly puts the speed, accuracy, and cost-efficiency of its decision models where they matter most.

Experience link: https://karpo.ai/models/decision/ten-appetites
[1]https://huggingface.co/MachinePulseAI/karpo-decision-31B
[2]https://github.com/machinepulse-ai/karpo-browserbench
[3]https://huggingface.co/MachinePulseAI/karpo-decision-27B-act
[4]https://github.com/machinepulse
- AI cranks out an MV live for a band—is this a hackathon or a music festival? 2026-11-21
- Chinese computing embarks on a new path to the summit 2026-11-21
- 80,000 group chat messages turned into an exam: Tencent Yuanbao × KCL release the first Agent memory benchmark built from group chats 2026-11-21
- Going viral across the internet! Grok's leading lady teaches you how to submit 3,000 PRs a month 2026-11-21