Bridgewater's Fine-Tuned Model Beats GPT, Claude, and Gemini at 13.8x Lower Cost

Frontier LLMs are surprisingly bad at one of the most routine tasks in finance: deciding which documents are actually worth reading. Bridgewater's AI and Automation Labs, in collaboration with Thinking Machines Lab, just published a detailed case study showing how they built a custom model that outperforms every frontier model they tested , GPT, Claude, and Gemini , on six financial information-filtering tasks, while costing 13.8x less per task to run.

The problem no one talks about

Every investor is buried in documents: news articles, central bank releases, research reports, internal memos. The real work isn't reading , it's the constant low-level triage of deciding what's worth reading in the first place. The real work is the small, repeated judgments carried over it , filtering, interpreting, segmenting, and identifying where the useful signal lies. These micro-decisions are embedded throughout an investor's day and consume enormous time.

The team wanted to automate this triage. But when they tested frontier models on six concrete tasks drawn from real investor workflows, the results were sobering. Variants of Gemini, Claude, and GPT averaged a mere ~50% accuracy when given a prompt that simply states each of the six tasks to perform , essentially a coin flip.

The six tasks they evaluated were:

• Financial Article Relevancy , is this news article relevant to a C-suite macro investor?
• Central Bank Document Relevancy , does this central bank release signal future rate changes?
• Generic Document Relevancy , does this research doc answer a specific investor question?
• Ad Hoc Content Labeling , is this document recurring boilerplate or does it contain one-off analysis?
• Document Truncation , where does the boilerplate begin in a document?
• Email Truncation , where does the boilerplate begin in an email?

Why prompting alone hits a wall

The team didn't give up on frontier models immediately. Their experts wrote detailed task descriptions and reframed certain problems , for example, splitting the "relevant" label into three buckets: relevant and interesting, relevant but uninteresting, and irrelevant. These changes boosted accuracy from a coin flip to the mid-70s. Automatic prompt optimization methods added nothing on top of that.

With their best prompts, frontier models still achieved less than 80% accuracy , the threshold investors expect from a system they could trust in their daily workflow. And newer models weren't closing the gap. Their results suggest that newer models aren't improving rapidly at this task, especially per dollar spent , GPT 5.4 costs 43% more than 5.2 but is only marginally more accurate.

The core issue is that expert judgment is hard to put into words. An explicit prompt can only capture what an investor can articulate. The judgment that matters most , why a small-cap IPO is irrelevant to a macro fund, or why a Greenland headline doesn't move markets , lives below the level of language.

Building the dataset: the hardest part

Fine-tuning requires labeled data, and this is where most teams fail. The team initially sourced labels from non-expert vendors. Models trained on this dataset still performed poorly. After examining the reasoning traces of the model, they realized that the labels in the dataset were often wrong.

Their fix was clever: train a model on the noisy labels, then flag every example where the model's answer disagreed with the label. Examples where the model's answer differed from the labelers' were sent to experts for reevaluation , if a model couldn't match an example from its own training set, either the example is genuinely difficult or the original label was wrong. This routing scheme let them get expert-quality labels at a fraction of the cost of labeling everything by hand.

Three training tricks that made it work

The team trained on Tinker, Thinking Machines' fine-tuning API, using Qwen3-235B as the base model. They started with standard GRPO (a reinforcement learning algorithm that doesn't need a separate critic model), which already jumped accuracy from 44.8% to 73.5%. Then they stacked three additional techniques:

1. Interleaved batching. For multi-task training, they compared training tasks sequentially, mixing them randomly, or rotating through one batch per task in round-robin order. Interleaving worked best, improving accuracy by 12.1% over fully mixed batches.
2. CISPO loss with asymmetric clipping. This replaces the standard importance-sampling loss used in GRPO. Importance sampling is a technique that reweights training examples to correct for the fact that the model generating data is different from the model being trained , asymmetric clipping controls how aggressively those weights are applied in each direction. Across the loss functions and clipping schemes they tried, this performed best, improving accuracy by 10.1% over the importance-sampling baseline.
3. On-policy distillation with a rolling teacher. On-policy distillation (OPD) is a training method that combines the best of reinforcement learning and supervised learning: it samples outputs from the student model itself (keeping training "on-policy"), then uses a larger teacher model to score every single token , not just the final answer. This gives much denser feedback than RL. Every 20 steps, they promote the current checkpoint to the teacher , but only if validation accuracy has reached a new high, so they never distill toward a weaker model. This gave a further 3.1% gain over a frozen base-model teacher.

Here's a simplified version of the core OPD training loop, adapted from the Thinking Machines OPD blog post:

# Sample from the student, score with the teacher
trajectories = do_group_rollout(student_client, env_group_builder)
student_logprobs = trajectories.loss_fn_inputs["logprobs"]
# Teacher scores every token of the student's output
teacher_logprobs = teacher_client.compute_logprobs(trajectories)
reverse_kl = student_logprobs - teacher_logprobs
# Use token-level KL as the advantage signal
trajectories["advantages"] = -reverse_kl
training_client.forward_backward(trajectories, loss_fn="importance_sampling")

The results

The trained model improves average accuracy from 78.2% to 84.7%, a 6.5% gain. Error rate falls from 21.8% to 15.3%, meaning the trained model makes 29.8% fewer mistakes than the best frontier baseline. That's enough to cross the 80% trust threshold investors require.

The cost story is equally compelling. The trained model is also vastly cheaper due to its smaller size: a 13.8x reduction in inference costs per task. At scale , running thousands of document-triage decisions per day , that difference is enormous.

What this actually means for the field

The broader implication here isn't just about finance. The team is describing what they call "differentiated intelligence" , the idea that custom models tuned to specific organizational needs outperform frontier models. This is a direct challenge to the assumption that scaling and prompting frontier models is always the right path.

The key insight is that expert judgment often can't be verbalized. When the gap between what an expert knows and what they can write in a prompt is large, fine-tuning on expert-labeled examples is the only way to close it. Prompting has a ceiling; training doesn't.

The infrastructure piece matters too. Tinker lets researchers focus on datasets, algorithms, and environments without the complexities of compute and infrastructure. Tinker uses transparent per-token pricing that varies by model size , training Qwen3-8B costs $0.40 per million tokens. New users receive $150 in credits when cleared from the waitlist, which covers several experimental training runs. The ability to iterate quickly without managing GPU clusters is what made the multi-ablation training recipe feasible for a team that isn't a frontier lab.

For any organization sitting on proprietary labeled data , legal, medical, scientific, financial , this work is a strong signal: the moat isn't the model, it's the data and the training recipe to exploit it.