A 4B Agent Just Beat a 235B Giant at Real Office Work — By Training on Real Work, Not Fake Tasks

Ask your AI agent to "finish the quarterly report" and watch what usually happens. It opens the files, skims them, and hands you something that looks finished — a neat spreadsheet, a polished slide deck, a confident summary. Then you open the spreadsheet and the totals don't add up. The deck quotes a figure that appears nowhere in the source files. The summary invents a meeting that never happened. The deliverable is plausible, professional-looking, and wrong.

That failure has a name in the research world: shortcut behaviour. Agents learn to produce deliverables that look done before they have actually grounded their work in the files, built the thing properly, or verified any of it. A new paper from Teng Pan and colleagues asks a blunt question: what if the problem isn't the agent, but the training data? Their framework, Agent-R², trains agents on real work — real occupational tasks, real files pulled from the web, real rubrics for what "done" means — and the results are startling. A 4-billion-parameter model trained on just 4,000 such tasks beat Qwen3-235B, a model roughly 59 times its size, on two realistic productivity benchmarks. The paper is "Agent-R²: Scaling Agents for Realistic Productivity Work via Real-Source Data Synthesis" (arXiv:2611.08219, 5 November 2026).

What the researchers did

First, they named the bottleneck. Large language models have made rapid progress in agentic reasoning and tool use, but real productivity work is not a chat prompt. Success requires following long-horizon professional workflows, understanding heterogeneous file contexts — a spreadsheet here, a PDF there, a slide deck somewhere else — and producing usable deliverables under fine-grained requirements. The authors argue the key bottleneck is the lack of scalable post-training data that reflects real work intent, authentic file environments, and deliverable-level evaluation. Most agent training data is either hand-specified by researchers or generated by LLMs themselves — clean, tidy, and nothing like the messy reality of an actual job.

So they built a synthesis pipeline grounded in reality at every step. Instead of manually specified workflows or LLM-generated files, Agent-R² grounds synthesis throughout in three real sources: real occupational seeds (the kinds of tasks actual professions involve), corpus-derived workflow evidence (how those tasks really unfold), and authentic web-sourced files (the genuine documents, spreadsheets and slides such work runs on). From 10,000 web-corpus candidates, the framework distils 4,000 task instances — each one pairing real multi-format attachments with a fine-grained, deliverable-level rubric that spells out exactly what a good result looks like.

Then they trained a model on it. Agent-R²-4B is trained with supervised fine-tuning followed by rubric-based reinforcement learning — the reward signal comes from the same deliverable-level rubrics the tasks are graded against, so the model learns to satisfy the actual requirements of the work, not just to produce something that reads well. Trained on only 4,000 instances, Agent-R²-4B surpassed Qwen3-235B-A22B-Thinking-2507 on both benchmarks the authors report: GDPval, 51.0% versus 48.0%, and OfficeQA, 14.8% versus 13.8%. A 4B model beating a 235B model at the very work agents are supposed to do — with a training set smaller than a single department's monthly ticket queue. Their analysis shows the training also mitigates shortcut behaviour — the habit of producing superficially plausible deliverables before grounding, constructing, or verifying them — while promoting sustained exploration: the trained agent spends longer actually working, reading the files, building the deliverable, and checking it against the requirements.

Why it matters

First, the training data was the bottleneck, not the model. The instinct in 2026 is to scale up — bigger model, more parameters, more compute. Agent-R² shows that a 4B model trained on 4,000 real tasks beats a 235B model on real productivity work. The giant wasn't beaten by a bigger giant. It was beaten by better homework. If your agent underperforms, the first question may not be "which model?" but "what was it trained on?"

Second, fake tasks teach fake work. When training tasks are invented by researchers or generated by LLMs, they are clean by construction: tidy inputs, obvious requirements, no missing files, no contradictory numbers. Real work is the opposite — the brief is vague, the spreadsheet has a hidden sheet, the PDF contradicts the email. Agents trained on tidy tasks learn tidy habits, then collapse on the first messy one.

Third, shortcut behaviour is the enemy, not stupidity. The agents failing your reports aren't dumb — they're optimised for the wrong thing. Producing a plausible-looking deliverable quickly is rewarded by every casual evaluation; actually verifying the numbers is slow, invisible work. Agent-R²'s analysis reframes the problem: the fix isn't more capability, it's an incentive structure that makes cutting corners cost more than doing the work. That is a design insight anyone building agent workflows can use today, no training run required — and a deliverable-level rubric is exactly that incentive structure: if you can't write down what good looks like, your agent can't learn to produce it.

Finally, small models are back in the productivity game. A 4B model that beats a 235B model on office work changes the economics completely: it can run locally, cheaply, privately, on hardware a small team actually owns. Realistic productivity may be a data problem with a small-model solution — and that is good news for everyone who can't afford a frontier API bill for every spreadsheet.

How YOU can use it

You can't download Agent-R²-4B from the paper — the abstract announces no public code or model release. But its core ideas are immediately usable in any agent workflow you run today:

Step 1: Ground before you generate. The paper's first move is to give the agent the real files, not a summary of them. Do the same: when you hand an agent a task, attach the actual spreadsheet, the actual PDF, the actual deck — multi-format, messy, unabridged. An agent that has only ever seen your paraphrase of the data cannot verify anything against the data.

Step 2: Write the rubric before the task. Before you prompt the agent, write a fine-grained, deliverable-level rubric — the same kind Agent-R² trains against. What does "done" look like, in checkable terms? The prompt template below is a starting point:

TASK: Build the Q3 sales summary from the attached files.
RUBRIC (the deliverable passes only if ALL hold):
1. Every figure in the summary traces to a cell in sales_q3.xlsx
   (cite sheet + cell for each number).
2. Totals match a recomputed SUM of the source rows — show the check.
3. No figure appears that is not in the source files.
4. Output is a .xlsx with one sheet per region + a totals sheet.
5. List every assumption you made, and every file you could NOT open.
DO NOT present the deliverable until all five checks pass.

Step 3: Ban the shortcut explicitly. Tell the agent what Agent-R²'s training taught its model: grounding first, construction second, verification third, presentation last. A one-line instruction — "do not show me the deliverable until you have verified every number against its source" — flips the incentive from looking done to being done. The illustrative sketch below shows the shape of a verification loop you can build around any agent call.

ILLUSTRATIVE sketch — not code from the paper:

# Rubric-check loop: verify the deliverable BEFORE presenting it
# (Illustrative sketch — not the paper's code. The paper's finding:
#  agents take shortcuts unless graded against a deliverable rubric.)

def run_task_with_rubric(agent, task, files, rubric):
    draft = agent.produce(task, files)          # ground -> construct
    for check in rubric:                        # verify, don't trust
        result = check.verify(draft, files)
        if not result.passed:
            draft = agent.fix(draft, result)    # repair, then re-verify
    return draft  # only now is it shown to the user

Step 4: Judge agents on deliverables, not demos. Stop evaluating agents on chat answers and start evaluating them the way Agent-R² does: real tasks from your own work, real files, a written rubric, a binary pass/fail per requirement. Build a small benchmark from last month's actual tickets — ten tasks, each with its files and its rubric — and run every agent or prompt change against it. The agent that wins your demo may not be the one that survives your inbox.

Step 5: Watch for the data and the follow-ups. Check the arXiv page for code and dataset links as they appear. The more interesting thing to watch is the pattern: real-source synthesis is a recipe other teams will copy, and the next wave of small, cheap, locally-runnable productivity agents will likely be trained this way. When you evaluate the next "office agent", ask one question first — was it trained on real work, or on homework someone made up?

Key takeaways

• Real productivity work defeats most agents: long-horizon workflows, messy multi-format files, and fine-grained deliverable requirements.
• Agent-R² fixes the training data, not the model: synthesis grounded in real occupational seeds, corpus-derived workflow evidence, and authentic web-sourced files.
• From 10,000 web-corpus candidates it distils 4,000 task instances, each pairing real attachments with a fine-grained, deliverable-level rubric.
• Agent-R²-4B — trained with SFT plus rubric-based RL on just those 4,000 instances — beats the ~59x larger Qwen3-235B on GDPval (51.0% vs 48.0%) and OfficeQA (14.8% vs 13.8%).
• The trained agent takes fewer shortcuts and explores longer: it grounds, constructs, and verifies before presenting a deliverable.
• Your move today: attach the real files, write the rubric first, demand verification before presentation, and judge agents on real deliverables.

Read the original paper: Agent-R²: Scaling Agents for Realistic Productivity Work via Real-Source Data Synthesis (arXiv:2611.08219) by Teng Pan, Zixuan Wang, Yuchen Yan, Qifei Wu, Yao Chen, Yingqi Qu, Ruiqing Zhang and Yongliang Shen. Link: https://arxiv.org/abs/2611.08219