Sepehr Akhavan

تنها شکستی بیهوده است که فاقد مبارزه باشد ...

[Anatoli Kopadze @AnatoliKopadze]

This is f*cking gold.

I've just made the clearest explanation of graph engineering you'll find anywhere.

No jargon, no code, no 2-hour lecture, just the four shapes every agent graph is built from.

Read on, and you'll never build with AI the way you did before.

-------

Shape 0 - Basics

A graph is just a plan for your AI work, drawn out so you can see it - which jobs run and which one waits for which.

Graph engineering is the skill of drawing that plan well, so the work that doesn't depend on anything runs all at once, instead of one slow step at a time.

Get it right and one person can direct a whole fleet of agents. That is why the best engineers jumped on it the moment loops got old.

-------

Shape 1 - The Chain

This is the one everyone builds by default.

Do A, then B, then C, each step waiting politely for the last to finish. It works, and it is the slowest shape there is.

If one step stalls, everything behind it stops. Use it only when the steps genuinely need each other's output.

-------

Shape 2 - The Diamond

This is the workhorse of every serious graph.

You split the job, fan the workers out in parallel, verify what they found, then merge it all into one answer.

Use it the moment the work breaks into pieces that don't read each other. Same shape behind a research report, a market scan, or a code review.

-------

Shape 3 - The Router

Sometimes the next step depends on what you just found.

One node checks a result and picks the path. a small job gets a quick pass, a big one triggers a full audit.

Use it when the work needs to branch. The decision runs the same way every time, because it lives in the structure, not in a guess.

-------

Shape 4 - The Cycle

Some jobs you can't size up front.

A bug sweep where finding one problem reveals three more. So you add a controlled edge back: keep finding, checking, looping until two rounds turn up nothing new, then stop.

Use it for discovery of unknown size. The one rule is a hard limit, or it runs until your budget is gone.

-------

That's the base, now you know the four shapes and when each one fits.

If you want to go deeper, I wrote a full article just for that, it explains everything step by step and breaks down where graph engineering wins and where it breaks.

It also walks you through building your own graph from scratch, read it below.

[Sepehr Akhavan @SepehrAkhavan]

So many brilliant people miss out simply from lacking access to key trends or hidden know-how.

AI acts as the ultimate equalizer. When you combine your talent + curiosity with it, new horizons open instantly.

The gatekeepers are gone. I’ve never felt more unchained.

[Alex Kotliarskyi 🇺🇦 @alex_frantic]

How to graph-max with Codex and 5.6 Sol:

1. Draw a graph (literally in any tool, even on paper)
2. Send it to Codex and say "write a code mode script that implements this workflow, run it with <your inputs>"

There's no step 3, it just works.

Seriously it's that simple.

[Mira Murati @miramurati]

The knowledge that makes AI useful is diffused. It lives with scientists, engineers, clinicians, firms. For AI to benefit from distributed knowledge, it must itself be distributed. Agree with Jensen that this is a future worth building.

[Thariq @trq212]

We removed ~80% of the Claude Code system prompt for our newest models, this is what we've learned about writing system prompts, skills and Claude.MDs for them. https://t.co/6DZwSrZjE9

[Blaber @4rblaber]

Anthropic engineers on building evaluation harnesses, testing agentic loops, and verifying system end-states:

• 02:18 - Moving from text output to agent outcome evaluation
• 05:43 - Architecture and mechanics of an Eval Harness
• 10:48 - Converting production failures into test tasks
• 14:52 - Code-based checks vs LLM-as-a-judge calibration
• 17:09 - Structuring Regression & Capability test suites
• 24:32 - Q&A with Anthropic Applied AI engineers

in this 45-minute deep dive, Anthropic Applied AI engineers alongside Notion's PM break down how to systematically test autonomous systems from scratch.

Agent Harness + Regression Suites + End State Verification = Reliable Agents

Watch the full session today, then build your own evaluation suite.

[Sepehr Akhavan @SepehrAkhavan]

@AndyRobsonTips @grok what is the issue here that Messi is upset about?

[Deedy @deedydas]

The story of AI in the next few years is going to be compute: an essay on the future of AI.

K3 in 2 days is already #10 on OpenRouter with ~140B tok/day, and it’s infra is crumbling. Throughput is down from 30tok/s to 13tok/s, E2E latency is up to 72s and time to first token is >20s! It would cost a minimum of $500k to buy the 8 B300s it would take to serve even quantized Kimi K3 and ~$4M for the more recommended GB300 NVL72 rack.

I don’t think Moonshot has the compute available to scale to their demand! In fact, even the US based inference providers will likely not be able to scale capacity as much as they’d like even if they were to host it: a 2.8T model is no joke. GPU providers (neoclouds etc) are doing 3yr and I recently hear 5yr commits with an ungodly 30% down, and customers are chomping it up. Prices continue to go to the moon. The two big labs, hyperscaler clouds, Grok and Meta have compute deals locked in prior, and the rest are fighting for scraps. Tier 1 neoclouds (coreweave/nebius etc) are rumored to not even small “smaller” customers. Meta is the biggest wildcard here. With ~7GW of compute by eoy 2026 and no clear big model ties, they either get to frontier on their own or can host the most Kimi K3 capacity (unless they sell it to the labs).

Even though the price of models has fallen over time, it’s worth noting that the price of frontier has not. 3yrs ago, GPT-4 released at $60/M, o1 at $60/M, Opus 4 at $75/M, GPT5 at $10/M, Fable at $50/M and now Sol at $30/M and K3 at $15/M. Even if you consider K3 frontier, that’s only a 4-5x flux in 3yrs. In that time, frontier demand has increased at least 3+ ooms and frontier intelligence performance has gone 32x at least by task time by METR.

Essentially, so long as a) the demand for frontier intelligence continues to grow to near infinity, b) the frontier continues to grow in performance, even as c) if the price of frontier declines a little, the value accrued to frontier grows significantly! And there’s a tremendous bull case for those who have locked up compute if you’re bitter lesson pilled and believe larger models will always be smarter models.

[Jun Song @jun_song]

Open Source AI updates :

> GLM-5.2 ✅ Almost Opus-level
> Kimi-K3 ✅ Almost Fable-level
> Qwen-3.8 🔜 2.4T, Expected to beat Opus
> Deepseek V4 GA 🔜 $0.0028/M Expected to beat Opus
> Minimax-M3-Pro 🔜 3T, Expected to be Fable-level
> GLM-5.5 🔜 Expected to beat Opus

Holy

[Yulun Du @Yulun_Du]

https://t.co/6ay3t9fLhu

Our Kimi K3 blog is finally out. Enjoy!—and rest assured, the K3 model weights will be open in the coming day. We’re just taking a little extra time to ensure a smooth rollout with our inference partners.

Frontier intelligence belongs to everyone, without fallbacks of course. 😎

[liam. @liambraus]

el fundador de una empresa china de IA valorada en más de $20,000,000,000 acaba de dar una clase de 40 minutos sobre enjambres de agentes

la explicación más clara que he visto sobre sistemas de IA a gran escala

cámbiala por tus 2 horas de Netflix de esta noche

[Xiaoyin Qu @quxiaoyin]

My bet: @thinkymachines will soon make more money than @AnthropicAI. Not by winning the race to build one standardized frontier model. By becoming the Palantir FDE for enterprise custom models.

The playbook:
1. Release the best American open-weight model.
2. Drive widespread enterprise adoption.
3. Charge the largest companies 7–9 figures to post-train and run custom models behind their own firewall.

The model rests on three bets:
1. Large enterprises will increasingly demand their own models with their own data, and this is how they differentiate and win.
2. Enterprises won’t need just one model. They’ll continuously need new models for different workflows, departments, and proprietary datasets. That creates extremely sticky, recurring revenue.
3. Autoresearch will make custom model development increasingly scalable. Tinker can become the interface enterprises use to post-train their own models—with @thinkymachines providing the expertise and infrastructure behind it. FDE, infra, everything, huge contracts.
4. Eventually, maybe everyone wants their OWN model, and autoresearch and training inside tinker on top of @thinkymachines's base model will make it happen.

Meanwhile, Henry-ford-styled, standardized models will makes no margins. OpenAI and Anthropic will have their API margins squeezed by Deepseek/GLM/Grok/Meta etc, and their consumer subscriptions are loss centers.

The fat margin will move to customization: proprietary data, post-training, evals, deployment, and infrastructure.

If this thesis is right, @thinkymachines isn’t building just another frontier lab. It’s building the highest-value layer between frontier research and enterprise model ownership.

Turns out, the best business model for enterprise is NOT to sell commodity API access. Sell them their own models.

I’m extremely bullish on this approach.
@miramurati may be the most commercially savvy frontier-lab leader. I have to admit it.

[h100envy @h100envy]

Google engineer explained how to fine-tune a tiny LLM from 46% to 90% accuracy on your phone in 21 minutes - better than $1500 on-device AI bootcamps.

pick Gemma 270M -> generate synthetic task data -> fine-tune with LoRA -> quantize to int4 -> deploy to Pixel and hit 2000 tokens per second.

That loop is how a 270M model beats a 70B one on your task, running fully offline in your pocket.

Gemma 270M + synthetic data + LoRA + int4 quantization + on-device runtime - that's the stack.

Watch and save it, then fine-tune your own tiny agent tonight.

[Thinking Machines @thinkymachines]

Today, we are introducing Inkling.

Inkling reasons efficiently across text, image, and audio modalities. We are making the full weights available.

https://t.co/Ghebq5mG30

Available today for fine-tuning on Tinker. Play with it in the Inkling Playground. 🧵

[Soham Ray @sohmray]

https://t.co/jndnEY0U8B

[Demis Hassabis @demishassabis]

https://t.co/PTeDiv1b6L

[Carlos E. Perez @IntuitMachine]

🧵 Researchers ran the same 22 enterprise tasks on six different foundation models—
Claude Sonnet 4.6,
Gemini 3.1,
Flash 3.5,
Qwen 3.6,
GLM 5.1, P
almyra X6.

Same prompts. Same judges. Same price table.

Only one thing changed: the orchestration layer around them.

What happened?
1/
The bill for every single model dropped 33% to 61%.
Median latency fell 44%. Tokens per task dropped 38%.

And headline quality? Held at parity.

On this workload, the orchestration layer moved cost more than switching between the cheapest and most expensive model did.
2/

The dominant pattern in agentic AI today is what we call token maxing:

Buying capability by throwing more tokens at it—longer reasoning traces, wider tool catalogs, full history replays every turn.

Falling per-token prices mask the pattern. But total spend rises anyway.

3/

The decisive lever isn't the model. It's the harness—the orchestration layer that:

• Assembles context
• Exposes tools
• Sequences turns
• Delegates work
• Governs failures

The harness controls every input token except the model's own verbosity. Which means it controls the bill.

4/

Here's the cost formula for one agentic task (Eq. 1):

C = Σ (p_in × T_in + p_out × T_out)

The input side breaks down into terms the harness builds:

T_in = System + History + Tool schemas + Retrieval + User turn

Four of five terms? Pure code decisions.

5/

A naive loop replays the full transcript every turn.

Total input tokens grow quadratically: O(k²) in turn count.

A harness that caches the stable prefix, compacts history, and offloads bulky tool outputs converts that to O(k).

Same model. Radically different bill.

6/

Two further facts sharpen this.

Agent workloads are input-dominated.

Measured ratios are ~100:1.

So the p_in term is nearly the whole bill.

Prompt caching prices cache reads at ~0.1× list.

If you can hold 99.9% of your prompt stable, you pay a tenth of list for the dominant cost term.

7/

The researcher's harness does exactly that with cache-shape discipline:

A byte-stable prefix (tool schemas + stable system prompt + append-only transcript) + a volatile tail rebuilt each turn (clock, plan, reminders).

Measured: 99.9% of tokens served as cache reads.

The same mechanism that cuts the bill also cleans the model's working set.

8/

Six mechanism families implement the harness:

1. Cache-shape discipline (two-zone prompt)

2. Structured, incremental, cache-aware compaction

3. Context offload (sub-agent firewalls, filesystem pointers)

4. Zero-token waiting (durable suspends, not polling)

5. Failure-spend governance (typed failures, circuit breakers)

6. Model-agnostic floor (normalized streams, native tool calling)

9/

Quality moved with capability.

Researchers measured quality gain vs. baseline strength across six models.

Correlation: r = 0.99

Stronger models extract more quality from the same harness. Weaker models can be overwhelmed by it.

We call this harness leverage.

10/

The harness also added one net-new capability: sub-agent delegation (spawn a scoped child, cap its summary at 8 KB, merge results).

But it only crossed a usable reliability threshold on the two strongest models (0.85–0.86).

Orchestration features carry capability floors.

11/

Per-model cost reductions:

• Sonnet 4.6: −39%
• Gemini 3.1: −33%
• Flash 3.5: −61%
• Qwen 3.6: −44%
• GLM 5.1: −47%
• Palmyra X6: −52%

Every. Single. One.

That's the signature of a layer-level effect, not a model-specific trick.

12/
Now, fleet economics.

At one million agent tasks per month:

Baseline: $210k/month
Harness: $120k/month
Savings: $90k/month. $1.08M/year.

From orchestration alone. And it stacks across every model, every vendor migration, every unit of volume.

13/

Three properties make harness savings compound:

• Model-portable: implemented above the API, applies to models that don't exist yet.
• Volume-linear: grows with exactly the quantity (agentic task volume) growing fastest.
• Stackable: multiplies with routing, per-token price declines, and prompt-level compression.

14/

The managerial fix is a measurement fix.

Teams that report quality alone will token-max, because tokens are someone else's line item.

The escape: CPM (task-completions per million tokens) and η$ (quality per dollar).

We moved CPM from 54.9 to 92.0—opposite to the industry trajectory—while quality held.

15/

One caveat: the harness regressed quality on one task (multi-step research synthesis, 0.80 → 0.60).

The regression was driven by the smaller models.

The honest reading of n=22: lead with efficiency (uniform, decisive), not quality (directional).

16/
The broader claim: token maxing is a choice made at the orchestration layer, and it can be unmade there.

Mechanism by mechanism:
• Cache the stable
• Compact the old
• Offload the bulky
• Suspend the waiting
• Bound the failing

17/

The contrarian takeaway:

"Model choice is now a rounding error compared with orchestration hygiene."

"The fastest way to raise quality per dollar is to stop showing the model 60% of the tokens it currently sees."

"Sub-agent delegation is not a feature—it is a capability tax that only frontier models can afford to pay."
19/

The strategic conclusion:

An organization that rents its orchestration layer has outsourced the variable it controls most.

The harness is not plumbing. On the evidence here, it's the P&L.

Paper: https://t.co/FZE7Uga7gh

[Krishna Agrawal @Krishnasagrawal]

Anthropic just dropped 5 workshops on building self-improving agentic systems from scratch:

00:00 - Ship your first Claude agent
36:44 - Build memory for Claude agents
1:05:06 - Make your agent autonomous
1:26:46 - Set up a proactive agent
2:03:35 - self-improving agents (tools,skills)

These 3-hours of free Claude workshops will replace 10 paid agentic courses.

Watch today, then read article below on how to build a self-improving agentic system with Fable 5.

[Carnage @0xCarnagee]

Prime Intellect engineer:

"everyone's bragging about a million-token context. here's what they don't tell you.

at 256k tokens GPT-5.5 scores 80% on retrieval. push it to a million and it drops to 36%. the model accepts the context, it just can't reason across it. people call it context rot."

in a 20-minute talk he explains why bigger context windows won't save your agents.

continual learning + training on your own traces + real environments - that's the fix.

Watch the talk, then save!

[Satya Nadella @satyanadella]

https://t.co/xv6csf1SbV