8 hard math problems were enough to nearly match training on 17,000 examples.
A new paper from Tsinghua and Meituan explores just how little data you need for on-policy distillation, and the results are pretty surprising.
The interesting part is that the model doesn't even need to solve those problems correctly.
In on-policy distillation, the student generates its own reasoning, while a teacher provides feedback along the way. Even when the final answer is wrong, the reasoning process can still provide useful training signals.
The researchers also found that harder problems tend to work better, not because they produce higher token entropy, but largely because they lead to longer chains of thought.
And those longer chains expose behaviors that rarely appear in short solutions: reconsidering an approach, exploring alternatives, and correcting earlier reasoning.
There's an important distinction here. Eight problems doesn't mean eight training steps. The same problems can generate many different reasoning trajectories.
What I find most interesting is the implication for training data. We usually think about dataset quality in terms of correctness, diversity, and scale. But perhaps we should pay more attention to how much useful reasoning a single problem can generate.
1/4
LobeHub is one of the more interesting attempts at building a Super-Agent platform.
It already combines CAO orchestration, async tasks, multi-agent collaboration, heterogeneous runtimes (Codex, Claude Code, DSH), and acceptance checks.
This goes well beyond a multi-agent chat UI.
2/4
What stands out architecturally:
β’ Tasks are first-class work objects, not just conversations.
β’ Execution backends are replaceable.
β’ Tracing is built into the agent runtime.
β’ Failure traces feed Harness improvements.
That last point is particularly interesting: operational feedback becomes a source of system improvement, not just debugging data.
3/4
But orchestration β reliable autonomy.
External agents still own their own sessions and permissions. And reported issues around subagent lifecycles, approval resumption, and device routing expose the harder problem: maintaining consistent execution state across boundaries.
A unified workspace is not yet a unified runtime.
4/4
My benchmark for a production-grade Super-Agent:
β’ Bounded, recoverable delegation
β’ Durable execution across interruptions
β’ Explicit authority and permission boundaries
β’ Evidence-backed acceptance
β’ Eval-gated self-improvement
LobeHub has built many of the right primitives.
The next challenge is proving they work reliably together over long-running tasks.
https://t.co/UXoRucAZEO
What if AI agents could operate desktop apps by reading their UI structure instead of guessing where to click?
That's what Vercel's open-source agent-desktop enables.
Instead of:
πΈ Screenshot β Vision β Guess coordinates β Click
It uses:
π³ Accessibility tree β Find UI element β Act β Verify
It works across macOS, Windows, and Linux, with CLI and MCP interfaces for coding agents.
The interesting part isn't just clicking buttons. It's giving agents a more structured way to interact with desktop software.
Still early, especially for apps with poor accessibility support, but a fascinating direction for computer use.
https://t.co/61DOpXHIbH
Most agent skills teach an AI how to do a task. What if you could teach it how an entire industry thinks?
Master Skill distills expert mental models, decision rules, tools, and workflows into reusable agent skills + CLI tools.
Worth exploring π
https://t.co/eTSeH9rY1E
Love how simple this is.
Looking through your skills repo, I noticed the skills are shared, while each project keeps its own config under docs/agents/.
That feels like a nice separation: one home repo for shared workflows and navigation, with project-specific context staying close to the code.
One thing I'm curious about: when an agent moves between repos, do you explicitly tell it to load each repo's local instructions, or let it discover them as needed?
@i_mika_el Exactly. Even a note from yesterday could already be wrong after a refactor π
I wonder if tying notes to specific commits would be more useful than timestamps alone. Have you tried anything like that?
Anthropic gave an AI agent 12 notes from earlier sessions.
I dug into what they reveal about agent memory, prompts, and harness design.
Full breakdown π https://t.co/B3A13t587f
@gagu_sh That makes sense for repo facts β the code and tests are the source of truth.
I'm curious how you handle behavioral instructions, though. If an old note says "never retry," how would your agent know that rule no longer applies?
Anthropic tested something surprisingly simple.
They gave an AI agent 12 notes carried over from earlier sessions.
Buried in those notes was one instruction:
"Never retry."
Then a tool got busy.
With those old notes in context, the agent retried only about 40% of the time.
Without them? It retried almost every time.
The interesting part is that the agent wasn't incapable of recovering from the error. It was following an instruction that shouldn't have applied to the current task.
And this wasn't the only surprising finding in Anthropic's new Claude Fable 5.2 prompting guide.
A single sentence about code ownership made Claude consolidate duplicate code in roughly 50% of trials, compared with less than 10% without it. But it also caused more unrequested edits.
A persistence instruction cut unfinished agent sessions roughly in half, while increasing output tokens by about 30%.
Even the way a subagent tool was described changed how often Claude delegated work.
These experiments point to a problem that gets more interesting as models improve:
What happens when a more capable agent inherits an entire system of instructions designed for older models?
4/5 RESULTS
β’ 30 min: 4 skills made a marketing kit (Reddit).
β’ ~30 min: buyer-psychology review of a ceramic mug page (The AI School).
β’ 25β30Γ faster: Eric Siu's estimate for his Claude Code work.
5/5 BEYOND ONE SKILL
The bigger idea is chaining them:
Product context β Research β Copywriting β CRO β A/B testing
One developer published a 3-phase playbook: Foundation β Base β Expansion.
Not just prompts. A repeatable marketing workflow.
https://t.co/xUV7w7Mypz
Your next marketing team might be a folder of Markdown files.
Corey Haines built an open-source library of AI marketing skills for Claude Code, Codex, and other agents.
In this thread π:
Where to find the skills
How to use them
Who's actually using them
Real-world results
How to build an AI marketing workflow
3/5 WHO'S USING IT
β’ Eric Siu: CRO for ClickFlow + SEO for Single Grain.
β’ A Reddit builder: a fictional product's positioning, landing page, emails and poster in 30 min.
β’ A SaaS developer: product video + SEO audit.
Reddit: https://t.co/0LU8PpLtxG
2/5 HOW
Install the skills (command in the image). Give Claude your product, audience and page.
Then ask:
"Use buyer psychology to find 5 reasons people hesitate. For each, explain the principle, suggest a fix and how to test it."
Start with product-marketing for context.
1/5 WHERE
Marketing Skills works with Claude Code, Codex, Cursor and more.
Start with:
β’ product-marketing: your product context
β’ marketing-psychology: why buyers hesitate
β’ cro: what to improve on a page
Free repo: https://t.co/yNYsuyaZMm
What if your coding agent could run an entire research workflow?
OpenResearch by alphaXiv turns Claude Code, Codex, and Cursor into research agents.
Here's what you can actually do:
Start with a research paper or an existing GitHub repo.
Let your agent review literature and propose hypotheses.
Run experiments locally or on remote GPUs.
Track results, code changes, and experiment history so the next iteration builds on the last.
The interesting part? You don't need to switch to a new AI agent.
OpenResearch provides the research workspace, experiment tracking, and compute infrastructure around the agents you already use.