MachinePulse Open-Sources Browser Agent Framework and 31B Decision Model

Original title: 反超Gemini之后,Karpo新作再开源,浏览器Agent速效双赢
78AI Score

MachinePulse AI has open-sourced Karpo Decision 31B, a low-latency decision model for agents, alongside the karpo-browser framework, a 27B Act action model, and the KBB evaluation set. On Browserbase Benchmark v2, the stack reports 89% average success at 201 seconds per task and $0.096 model cost per task, roughly 1.9x faster and about one-thirteenth the cost of the Claude Fable 5.2 setup.

Full Report

Contents12 sections

Speed beats Claude, at one-thirteenth the cost

Wenting, reporting from Silicon Valley

QuantumBit | WeChat Official Account QbitAI

It's 2026, and a young team has actually gone and trained a dedicated decision model—and on its first outing, it left Gemini in the dust?!

In the same "City Scanner" challenge, Karpo picked 10 good leisure and entertainment spots for me out of 36 events (average spend under $50, commute distance of just 5 km) in only 2.6 seconds, while Gemini 3.5 Flash took a full 14.96 seconds.

Nearly 6x faster! And it didn't miss a single filter condition, hitting 100% accuracy across all 36 questions.

This new decision-making ace is Karpo Decision 31B, just open-sourced by MachinePulse AI.

It's purpose-built to give Agents high-frequency, low-latency decision-making capabilities, making every judgment faster and cheaper.

For example, which button to click next when browsing a webpage, whether a task is complete, which of dozens of tools up for invocation best fits the requirements—it can deliver a judgment directly, and it works remarkably briskly.

A single RTX PRO 6000 is enough to put it to work. Facing more than 140,000 requests on a public set, its median response time is just 94 milliseconds—not even the blink of an eye.

On the Decision Index leaderboard, where a full 300 models battle it out, Karpo Decision 31B also claimed the top spot with a Full score of 73.9, judging up to 255 candidate options simultaneously per 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 trained specifically for webpage action decisions, and the accompanying webpage action decision evaluation set KBB.

On the 102 core tasks of Browserbase Benchmark v2, this solution achieved an 89% average success rate and an average time of 201 seconds, with a per-task model cost of only $0.096 (about 0.64 yuan).

Compared with the leaderboard-topping Claude Fable 5.2 + Claude Code, it completes tasks about 1.9x faster, and its model cost is just one-thirteenth of theirs.

We observed that when the success-rate requirement is relaxed to 80%, but with a genuinely user-usable experience of within 250 seconds and within $0.15 in cost, none of the 91 records on the entire leaderboard achieves it—Karpo alone does, and by a wide 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, averaged over 3 runs under stringent requirements, far exceeds the other models on the leaderboard, which only run 38 questions once.

Onlooking netizens couldn't help but marvel:

This is exactly what every tech stack needs!

Goodness, this AI strategist that makes decisions on behalf of Agents—just how many more tricks does it have up its sleeve?

While you're still waiting for the LLM to reply, Karpo has already finished the job

Speaking of which, ever since Jev exploded overnight this September, the decision-model track has leapt to become one of Silicon Valley's hottest star tracks.

In just 24 days, TypeSafe AI, the company behind Jev, landed a massive $7.5 billion (about 50 billion yuan) valuation.

For a time, tech giants like 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?

The reason is simple.

As Agents become more capable, if every tool selection or result filtering required calling a general-purpose LLM to generate an answer word by word, it would be a bit like using a sledgehammer to crack a nut.

Not only is it slow, but Tokens burn away furiously, and your wallet shrinks along with them.

Thus, decision models dedicated to handling these high-frequency, trivial judgments for Agents have found their calling.

But existing solutions each have their own difficulties.

For example, the wildly popular Jev and Google's newly launched Gemini Decision 1 can quickly produce decision probabilities, but neither is open-source, making it hard for developers to deploy on their own.

Decision models with open weights (such as GLiDE) don't necessarily max out both speed and judgment capability at the same time.

So Karpo Decision 31B went a few steps further: 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's fully open-source.

Take "Ten Appetites, One Menu," which I tried out on Karpo's official website.

It's a food-ordering mini-game where humans and AI compete head-to-head. Karpo Decision 31B and I had to order for 10 guests at the same time, catering to each one's budget, taste, and dietary restrictions, while seeing who could serve faster and more accurately.

It looked simple, but who'd have thought—I had just moved my cursor to the first guest's requirements and hadn't even finished reading the first line when Karpo Decision 31B had already, in 1.3 seconds, swiftly served all 10 dishes.

And it didn't get a single one of the 10 guests' requirements wrong!

I was... I was crushed?! No, no, steady now, 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 passed.

Good grief, Karpo would have handed in its paper 10 times over by now, and I was still stuck on the second question...

Now I got anxious. Starting from the third question, I simply cheated quietly—whatever it clicked, I clicked too.

But even copying the answers, I still couldn't catch up.

In the end, I threw caution to the wind and just clicked randomly, thinking maybe I'd get lucky.

But even after all that guessing and half-copying, it still took me a full 83.9 seconds to complete the whole task.

Meanwhile, let's look at the general-purpose LLM side.

For the same 10 questions, I also sent screenshots to GPT-6.2 Astra (High setting) to do them, and it took a full 34 seconds to get an answer.

By comparison, Karpo was not only 64.5x faster than me, a human player who had already secretly cheated, but also about 26x faster than GPT!

And this kind of judgment work is even more useful when placed in the context of developers' day-to-day Agent building.

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 a task is complete.

If every step required calling a general-purpose LLM and waiting for it to slowly generate an answer, not only would the workflow easily be slowed down, but the Token bill would rise along with it.

Karpo, on the other hand, can pack multiple judgments into a single request and directly return the probability of each candidate option, eliminating the overhead of generating answers token by token and giving agents a chance to run faster and cheaper.

More importantly, according to JevBench's GPU cost estimates, Karpo costs only about $0.025 (0.17 yuan) per 1,000 decisions, meaning that for just $1 (about 6.67 yuan), it can run nearly 40,000 decisions!

Compared with routinely calling general-purpose large models, the cost simply plunges.

And Karpo has actually brought this decision-making capability into the browser, substantially improving the user experience for web tasks!

The MachinePulse team has just 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, pairing a general-purpose large model with a dedicated decision model.

How is the work divided?

System 2 does the thinking, System 1 does the doing.

For example, suppose a user wants to book a restaurant.

The general-purpose large model DeepSeek V4.1 Flash is responsible for understanding the request, breaking down the task, and preparing the information that needs to be filled in;

while Karpo Decision 27B Act, trained specifically for web operations, is responsible for selecting input fields on the page, clicking buttons, and deciding which action 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 web pages, executing operations, and handling page changes and execution exceptions.

**△**Image generated by AI

And the results of this division of labor are actually quite something.

Across three rounds of testing on all 102 tasks in Browserbase Benchmark v2, the team found:

About 78% of operations on web pages were completed by 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 originally required repeated calls to a general-purpose large model and token-by-token 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 steps of web operations. Through real web recordings 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 invocation costs.

The MachinePulse 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 their original user scale with the same operating budget.

For developers who want to turn agents into products truly aimed at large numbers of users, this may be the more exciting part.

Picking projects quickly and accurately, and good at reading between the lines! Karpo has something going for it

Looking this good, of course I had to give it a roll right away!

So I also gave Karpo Decision 31B two challenges, 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?

First, let's test search result filtering.

Suppose we are looking for an open-source browser agent that supports local deployment and can actively click, fill in forms, and navigate web pages.

I threw 8 technical search results at Karpo all at once. At first glance, every one of them seemed relevant, but mixed in were various tools that can only be viewed but not operated, agents that can only run in the cloud, and projects that are fully featured but not open source.

The task is as follows:

Let's see whether it can single out the projects that truly meet the requirements.

As a result, in just 308 milliseconds (about 0.3 seconds), Karpo accurately picked out the four qualifying results A, D, E, and G!

It also did not miss any of the other four distractors mixed in among them.

Test 2: With all my sarcasm, can Karpo hear the implied meaning?

But decision-making is often not just about filtering results.

Chinese culture is profound and nuanced. Sometimes we cannot just trust the literal meaning. (doge)

Be like this sentence:

Great, this agent deleted all my files again. Really a big help!

Praise? Sarcasm?

If you only stare at the "Great" in the first half or the "big help" in the second half, you will definitely get it wrong.

So I gave Karpo another 6 tone-judgment questions, ranging from straightforward praise to sarcastic complaints to neutral expressions mixing praise and criticism, to see whether it can read the subtext and to what extent.

The tasks are shown in the image:

The results are actually quite good.

In just 232 milliseconds (about 0.23 seconds), Karpo Decision 31B gave judgments for all 6 questions, catching 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, so overall it's okay," a neither-praising-nor-criticizing, mixed evaluation.

It even gave a subtle perception of 91% neutral probability, 8% approval, and a faint 0.2% dissatisfaction.

The most interesting is the sixth sentence:

Not bad, you finally didn't crash the online service today.

Even though it 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.

So the affirmation of this task and the resentment over past crash incidents hidden behind this praise were completely picked up by it.

In developers' real-world applications, this capability is actually very practical.

For example, a customer service Agent determining whether a user is truly satisfied, or a development tool analyzing user feedback, both need to see through literal expressions to identify the real attitude, avoiding mistaking complaints for praise.

Saying Goodbye to Token-by-Token Generation While Avoiding Specialization Imbalance — How Was Karpo Forged?

At this point, you're probably curious too: how exactly does Karpo Decision 31B compress so many judgments into a single inference pass and 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 typically had to generate an answer token by token, and then a program would parse the final option from the text.

Karpo simply eliminates this step.

It assigns dedicated encodings to candidate options, and places a marker after each question for reading results. 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 a single forward pass — no token-by-token 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), letting Karpo distribute probabilities across up to 255 candidate options so the Agent knows which is more worth selecting.

What if the Agent has been working for a while and needs to determine whether the task is actually complete?

That's handled by Noul (Yes/No judgment), directly returning the probability that the task is complete.

As for how relevant search results are, or how well a recommended item matches user preferences, that can be handled by Score (rating), letting the model assign probabilities to different rating levels, which the system then uses to compute scores and adjust rankings.

Three question types, sharing the same Readout Head.

However, answering one question at a time isn't enough.

When an Agent actually gets to work, it may need to simultaneously filter through dozens of search results, compare dozens of tools, with a large chunk of web content or task context behind it all.

Surely it shouldn't have to recompute the same material for every single candidate it evaluates?

Karpo doesn't want to do that 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 that everyone uses in common, containing task instructions, question lists, web pages, and other background material; the other is each question's own Branch, containing the corresponding question, options, and result-reading markers.

Shared content is computed only once, while each question can be answered separately without interfering with each other.

△ Branch Attention architecture diagram

How significant is the effect?

On a single RTX PRO 6000, for requests of 1K–4K tokens, Karpo's median latency for answering a single question is only 371 milliseconds.

When a single request contains 16–63 questions, the median latency is only 653 milliseconds.

Dozens of judgments are batched together, yet latency doesn't grow multiplicatively with the number of questions — giving Agents the opportunity to dramatically reduce the overhead of high-frequency decision-making.

For developers, that's quite appealing.

However, being fast at judging also requires some self-awareness.

After all, whether the Agent executes automatically next or hands the decision back to a human often depends on how confident the model is in itself.

If it clearly only has a 60% chance of being right but confidently says 99%, that's a bit frighteningly overconfident. (doge)

To address this, Karpo also employs RLCD (Reinforcement Learning for Calibrated Decisions).

It doesn't just reward the model for choosing the right answer — it also computes rewards based on the entire set of predicted probabilities, encouraging the model to honestly report its confidence.

Even when labels in the training data are ambiguous, it tries to preserve that uncertainty rather than forcibly collapsing it into a single answer.

How well does it work?

On public JevBench questions, Karpo's Expected Calibration Error (ECE) is only 2.3%.

With this, developers can try setting different execution thresholds for the Agent, so it can act decisively when appropriate and also know when to hold back and hand things over to human oversight.

RSI Enters the Scene: Karpo Corrects the Specialization Imbalance Problem in Training

However, with speed and probabilities both solved, Karpo still faces another more thorny problem.

That is, it must not become specialized/imbalanced during training.

You see, the decision-making needs an Agent encounters every day are wildly varied.

Today it helps you filter open-source projects, tomorrow it might need to judge whether code has security vulnerabilities, and the day after it has to review a contract or procurement document.

If the model is only ever good at the kinds of questions it saw during training and falls apart when the scenario changes, that would be quite embarrassing.

And the Karpo team did indeed spot such warning signs during training.

As training progressed, the model's public benchmark score rose from 73.1 to 75.1, but its accuracy on evaluations across 13 unfamiliar domains actually dropped from 72.1% to 70.7%.

To solve this problem, the Karpo team made generalization ability 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, consolidates the strengths of different versions together.

The fused model can only advance to the next iteration if it outperforms the current model.

This time, the team selected 5 different checkpoints — 3 from full-parameter fine-tuning and 2 from LoRA fine-tuning.

Through weight averaging, they combined the better generalization ability of earlier models with the stronger specialization of later models.

The results were quite good. After fusion, the public benchmark score remained at 75.1, while accuracy on unfamiliar domains rose from 70.7% to 72.3% — a recovery of 1.6 percentage points.

Moreover, after fusion, it remains a standard 31B-parameter model — no increase in architecture, 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%).

No points lost on public questions, and actually better on unfamiliar ones.

For a decision model that wants to be embedded into various Agent workflows and take on different judgment tasks at any time, this ability to avoid specialization imbalance is probably more noteworthy than simply scoring a few more points.

Less Hesitation for Agents, More Freedom for Developers

Anyway, after testing things out for a while, what impressed me most was how deftly Karpo handles those high-frequency small decisions.

Today, decision-making is becoming a layer of capability in AI systems that can be independently divided up.

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 can even accomplish things that the latest OpenAI models cannot yet do, and they will become smaller, cheaper, and faster.

Diogo, founder of Jev, expressed a similar judgment:

In the future, AI won't 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 yet another open-source option for realizing this approach.

When Karpo was released, LeahW summarized its design philosophy this way:

Choosing the next tool shouldn't take a whole paragraph.

When judgments are fast enough and cheap enough, developers have the opportunity to arrange more fine-grained filtering and checks in an Agent's search, recommendation, and task execution workflows, without having to rely on generative large models for everything.

What's more interesting is that even Karpo's name exudes a free-spirited flair.

It comes from the Latin Carpe Diem, meaning "seize the moment, enjoy the present."

And the MachinePulse team behind Karpo has long been deeply engaged in the Personal Agent direction, which happens to address those real yet trivial little dilemmas in our daily lives.

For example, what should I drink today? How do I want to relax after work? What fun things are there to do nearby this weekend?

Sometimes, we only have a vague inkling in our heads, and can't even clearly articulate what we want.

What Karpo aims to do is turn these vague ideas into concrete choices, helping people fret a little less and get out the door sooner 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

And for the developer community, Carpe Diem now seems to carry an additional layer of meaning.

Leave the 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 open-sourced 6 full-size Karpo Decision models in total—0.8B, 2B, 4B, 9B, 12B, and 31B—so everyone can call on them according to their actual needs~

Moreover, this time even Karpo Decision 27B Act, which specializes in web action decisions, the browser Agent framework karpo-browser, and the accompanying evaluation set KBB have all been opened up to developers as well.

From making decisions for Agents to letting Agents actually get hands-on with work, Karpo truly puts the speed, accuracy, and cost-efficiency of decision models to the sharpest use.

Experience link: https://karpo.ai/models/decision/ten-appetites

Repository links:

[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/karpo-browser

One-click triple action: "Like," "Share," "Heart"

Feel free to leave your thoughts in the comments!

— The End —

🌟 Light up the star 🌟

Daily updates on cutting-edge tech progress

Open in WeChat