🗞️ GPT 5.6 Beats Fable 5 by on DeepSWE at a cheaper price.
GPT 5.6 tops Fable 5 on DeepSWE; 1X Neo tendon hands; Microsoft cuts Copilot costs; GitHub SpecKit; Anthropic code gains; DeepMind task advice;
Read time: 10 min
📚 Browse past editions here.
( I publish this newletter daily. Noise-free, actionable, applied-AI developments only).
⚡In today’s Edition (10-July-2026):
🗞️ GPT 5.6 Beats Fable 5 by on DeepSWE at a cheaper price.
🗞️ Today’s Sponsor: Toyo Brings Tool-Using AI Agents Into Everyday Conversations, into your iMessage and Telegram
🗞️ 1X Debuts Human-Level Robotics Hands - Neo’s Tendon-Driven Hands With 25 Degrees of Freedom
🗞️ Microsoft is replacing OpenAI and Anthropic models inside Excel and Outlook to cut Copilot costs.
🗞️ GitHub recently published this repo SpecKit, an open-source toolkit to fix a big weakness of vibe coding: that AI often starts coding before the product rules are clear.
🗞️ Claude Code creator Boris Cherny: Anthropic’s reported jump of roughly 250% in code written per engineer without a visible collapse in quality.
🗞️ Google DeepMind’s paper has some great advice on how we should actually give tasks to AI.
🗞️ A massive idea from this Shanghai University paper
🗞️ GPT 5.6 Beats Fable 5 by on DeepSWE at a cheaper price.
GPT-5.6 Sol reaches roughly 72% to 73% DeepSWE at about $8.4 per task, while Claude/Fable-5 tops out around 70% at a much higher cost, around $13 to $22 per task. DeepSWE is a coding-agent benchmark, not a normal code-generation test, because the model must work inside real open-source repositories and finish long software engineering tasks.
Each task gives the agent a repo and a requested change, then checks whether the final patch actually works using program-based verifiers, so the score means “what % of the 113 tasks were solved.” The benchmark tests repo navigation, bug diagnosis, code editing, tool use, test running, and multi-step repair across 91 repositories and 5 languages, not just writing a neat function from a prompt. On this benchmark, the best model is the one that solves the most tasks for the least average task cost.
🗞️ Today’s Sponsor: Toyo Brings Tool-Using AI Agents Into Everyday Conversations, into your iMessage and Telegram
The bottleneck of AI Agent is when I, as an user, need to become the operator.
It should feel more like a colleague in your messages. And that gap is filling up fast. Toyo just launched an AI executive assistant built around the interface people already use: messages.
Toyo product lives in iMessage and Telegram, so delegation starts as a normal conversation. People talk to Toyo in messages. Behind the scenes, Toyo handles tool access, context, and background workflows.
Toyo is now available for anyone to try, you can sign up here.
The shift here is that chat becomes the visible layer, not the full product. Behind that scene, Toyo connects to email, calendar, Slack, CRM, docs, meeting notes, and project tools.
That access lets one short message trigger a workflow across the places where work already sits. A user can ask it to watch important email, draft a reply, prepare a meeting, chase a follow-up, or send a daily briefing.
Toyo then handles the slower parts that usually make agent systems feel heavy. It pulls context, calls tools, keeps workflow state, runs scheduled checks, and asks for approval before sensitive actions.
Most people do not want to configure agents, monitor runs, inspect failures, or maintain automation chains. They want to delegate work, add context when needed, and review the output before anything leaves their account.
Toyo compresses that loop into messaging. It can be operated also by voice completely. A user can send a voice note, or Toyo can call when it needs more context.
And you can use code PRODUCTHUNT to get your first month free.
🗞️ 1X Debuts Human-Level Robotics Hands - Neo’s Tendon-Driven Hands With 25 Degrees of Freedom
The new humanoid hand for NEO from 1X.
Most robot hands fail because they move, but they do not properly feel contact.
- 1X’s answer uses low-ratio tendon drives, so outside forces travel back through each joint. The motors sit in the forearm, pulling tendons through the wrist like biological muscle.
This keeps the fingers light, lowers impact energy, and still allows strong gripping.
- The hand has 22 actuated finger and palm axes, plus 3 wrist axes. Those joints are not spread evenly, because the thumb carries much of human dexterity.
- A real opposing thumb is so needed, because grasping is mostly about control, not squeezing.
- Closed-loop proprioception gives NEO pose and effort data without using cameras.
- Tactile skin adds contact, pressure, and shear, so slipping objects can trigger fast corrections.
- IP68 sealing and food-safe materials mean the same hand can work near water.
- Backdrivable fingers also make impacts less dangerous, because the mechanism yields under force.
- 1X says full finger assemblies have survived millions of cycles during validation.
- Hundreds are already built, with capacity planned for 10,000 hands this year.
- The interesting part is the data loop. Every grasp can now return force, pose, contact, and slip signals for robot learning.
That makes NEO more like a measuring instrument.
🗞️ Microsoft is replacing OpenAI and Anthropic models inside Excel and Outlook to cut Copilot costs.
Excel and Outlook used to lean more heavily on outside models. Now Microsoft wants fewer expensive calls to labs that control pricing for frontier model access.
OpenAI still gives Microsoft favorable access through their long partnership, but that discount may fade.
Microsoft AI head Mustafa Suleyman has been clear that Microsoft wants to reduce, then remove, that outside cost.
🗞️ GitHub recently published this repo SpecKit, an open-source toolkit to fix a big weakness of vibe coding: that AI often starts coding before the product rules are clear.
It turns vibe coding from “ask the AI to build it” into “write the product spec first, then make the AI build from that spec.”
Most AI coding today starts with a loose prompt, then jumps straight into code, which often produces working demos but weak requirements, missing edge cases, and messy rework.
Spec Kit pushes the process the other way: first define what the product must do, then clarify gaps, then create a technical plan, then break that plan into tasks, then let the agent implement against those written artifacts.
So here the spec is no longer disposable documentation; it becomes an executable development contract that guides Copilot, Claude Code, Codex, Gemini, Cursor, Qwen, and 30+ other agent integrations.
🗞️ Claude Code creator Boris Cherny: Anthropic’s reported jump of roughly 250% in code written per engineer without a visible collapse in quality.
And here’s his advice for other companies to achieve the same.
- Companies should not over-control AI usage. Instead of making employees ask for approval for every token, companies should give people enough access to experiment and discover useful workflows.
- Psychological safety is essential for AI adoption. Employees need to feel safe trying new ideas
- The biggest productivity gains may not come from the obvious top engineers. They might come from accountants, marketers, new graduates.
“What happened with Claude is that now many companies, including Anthropic and all of our biggest customers, are reporting gains on the order of hundreds of percentage points.
I think the last number that we reported is that the amount of code written per engineer at Anthropic has grown something like 250% since we introduced Claude Code. This is while keeping code quality, reliability, and all these things kind of stable. So, without those things regressing, the volume of code has grown a lot.
This kind of productivity impact, I think, is just very new, and people are trying to figure out how to get this.”
🗞️ Google DeepMind’s paper has some great advice on how we should actually give tasks to AI.
It is not just about telling an AI to do something and hoping for the best. Instead, this framework looks at delegation as a string of choices where you figure out if you should even hand the task over, how to explain it, and how to check the work afterward.
Current systems rely on rigid rules that break when things fail unexpectedly. The researchers suggest building a dynamic market where agents bid on tasks using smart contracts.
This requires strict monitoring and cryptographic proofs to guarantee correct work without leaking private data.
Instead of trusting a simple rating, agents will use verifiable digital certificates to prove their exact skills.
- Keeping things flexible when things change
This new system is built to be adaptive rather than stuck in its ways. It treats the handoff as a live process where authority and responsibility can shift around in real time. If the situation changes or something breaks, the framework helps manage that failure so the whole project does not go off the rails. It works for both humans giving tasks to AI and for when AI needs to handle things on its own.
- Finding the right amount of trust
One of the coolest parts is how it handles trust. They made formal trust models that look at how hard a task is and how well the AI has done in the past. This stops people from “over-delegating,” which is when you give an AI something it is not ready for. It also stops “under-delegating,” which happens when you do all the work yourself even though the AI could have handled it easily.
- Double checking the work
You cannot just take an AI’s word for it, so this framework has specific ways to validate the output. It sets up rules for when to accept an answer based on how confident the AI is. It also has backup plans ready to go if the AI fails. This is super important for real world jobs where trusting a machine blindly could cause a bunch of errors to pile up.
- When AI agents hire other AI agents
The framework also covers what happens when 1 AI agent hands a task to another AI agent. The system tracks who is actually accountable and makes sure the right authority is passed down the line so nothing gets lost in the network.
- Making sure the work actually fits
It is a step by step approach to make sure the AI’s contribution actually makes sense for the bigger goal. By treating this as a structured process, they are making it much safer for companies to use AI in their daily operations without worrying about constant mistakes.
🗞️ A massive idea from this Shanghai University paper
Every time a new clue appears, the note must be rewritten, so older clues slowly fade or get squeezed out.
That is close to what happens inside fast AI models like linear-attention and state-space models, which save memory by compressing everything they read into 1 fixed internal state.
The problem is that this makes them very forgetful. In a “needle-in-a-haystack” test, where they need to recall a particular fact buried deep in a large document, they fail because fresh details overwrite the earlier ones.
HOLA tries to fix this by giving those models a second place to store details.
The normal state still handles the broad shape of the text, like grammar, topic, and repeated patterns.
The new memory cache stores exact pieces of information that the normal state seems likely to forget.
The clever part is how HOLA decides what deserves that cache.
It does not simply save the newest tokens, because old details can still matter later.
Instead, it saves the tokens that caused the biggest correction inside the model, which usually means the model struggled to compress them cleanly.
In plain terms, HOLA keeps the facts that surprised the model.
When the model later needs an answer, this cache is read in a sharper way, so it can pull back a specific saved fact instead of blending many memories into a vague guess.
This matters because fast models usually trade memory for speed, while full-attention Transformers keep stronger recall but become heavier as the text gets longer.
In the paper’s 340M-parameter test, HOLA lowered Wikitext perplexity from 27.32 to 22.92, beating the matched fast baseline and even beating the reported full-attention Transformer++ on that measure.
It also stayed much better at needle-in-a-haystack recall out to 32k tokens, even though it was trained on 2k-token contexts.
The bigger lesson is that a fast AI model does not need to remember everything exactly.
It needs to know which details its main memory is bad at keeping, then protect those details before they disappear.
That’s a wrap for today, see you all tomorrow.