How much do Chinese models cut your API bill? 🇨🇳

WITH THE SAME OUTPUT!!!

US frontier model → chinese open model, cost to do one task:

[ reasoning brain ]
Claude Opus 4.8 → DeepSeek V4 Pro
$1.80 → $0.04 per task
~45x cheaper, and it's tied with Opus on SWE-bench (80.6 vs 80.8)

[ code generation ]
GPT-5.5 → GLM 5.2
$1.03 → $0.48 per task
~2x cheaper AND it beats GPT-5.5 on long-horizon coding

[ agents + tool calling ]
Claude Sonnet 5 → Kimi K2.7
$2.29 → ~$0.31 per task
~7x cheaper, best agentic stability of the open models

[ bulk / high volume ]
Gemini 3.5 Flash → DeepSeek V4 Flash
$0.59 → $0.02 per task
~30x cheaper, plenty for extraction, classification, drafts

the tradeoff:
> coding + agents.. near parity or better
> hardest reasoning + world knowledge.. ~10-15% behind
> your bill.. down 2-45x depending on the task

one catch: Qwen3.7 Max is chinese but priced like frontier ($1.06/task).. cheap isn't automatic

route each task to the model that wins it:

code → GLM..
agents → Kimi..
value reasoning → DeepSeek..
bulk → DeepSeek Flash

keep a US frontier model for the 10% that truly needs it

You changed your phone number last year.

Someone else has it now.

Every time your bank, Gmail, or WhatsApp sends a code to that number, they get it. Not you.

Princeton tested 259 recycled US numbers. 171 could still log into someone's old accounts.

Here's how to fix it in 10 minutes 👇

Are We Ready For An Agent-Native Memory System?

First, what does that even mean?

It's memory built for an agent that keeps running, not a store you bolt on at the end. It has to hold facts across sessions, update them when they change, drop the stale ones, and hand back the right piece when the agent asks. A real data system, not a pile of saved chunks.

A new study checked whether anything out there actually does this, and what decides the answer surprised me.

It takes 12 agent memory systems and splits each into four stages, covering how memory is represented, extracted, retrieved, and maintained. Then it checks which stage decides whether the agent stays correct.

Turns out it's write time, not query time.

The systems that stay reliable under fact updates and cross-session reasoning are the ones that add structure as the memory is written. The graph-based methods lead right there.

The flat stores fail the same way every time. An LLM pulls out entities and relationships with no schema, and the graph fills up with generic nodes that nothing downstream can filter.

A few things follow from this.

→ Structure has to be set at extraction. Once the graph is built from untyped nodes, no query can recover a distinction the extractor never made.

→ Updates return stale facts. Append-only and freeform stores keep handing back old versions, which the paper calls hallucinations of the past.

→ A bigger model does not save it. Swapping the backbone moves the scores but rarely changes which pipeline wins, so the memory's behavior is set before generation runs.

The paper also weighs the cost. The heavily structured systems pay for it, sometimes orders of magnitude more time per query, and the win only holds when the upkeep stays local instead of rewriting the whole store on every change.

So the takeaway is less about picking a winner and more about where the structure lives. Decide it at write time, keep the maintenance cheap, and retrieval has something real to rank.

Retrieval only ranks what extraction chose to keep.

Link to the paper: https://arxiv.org/pdf/2606.24775

If you're into agent memory systems, I wrote a full article on exactly this. It walks through defining the schema as a Pydantic ontology in Zep, with custom entity and edge types, source and target constraints, and the extraction pipeline that turns raw conversations into typed, queryable memory.

This memory system is 100% open-source: https://github.com/getzep/graphiti

The article is quoted below.

📸 That glance back from above!
Made a set of “Low Gaze Portraits” with ChatGPT-Image2.

Young urban commuters with a preppy edge. She bends down to check her bag, then turns back toward the camera.

The side-rear low angle keeps the POV close, while the clear sky makes the frame cleaner!

Prompt below 👇