The gateway to the AI frontier.
- Tweets 1,357
- Following 350
- Followers 18,272
- Likes 2,941
You’ve probably heard the buzz around Looped transformers, but which one?
Over the past month, the same word covered three reuse tricks.
Implementing the wrong one burns a training week. It also budgets a 3B file like a 3B decode.
We opened a looped transformer open model, Nanbeige 4.2:
> 22 layers, two passes
> 44 applications, same weights
> About twice the block compute
> KV cache doubles with it
It kept about 75% of a standard Transformer's token efficiency.
Sharing the cache halved its memory. And quality gains were consistently lower.
A second design carries state token to token. Sequence length is the depth.
Training used 500 million tokens. That run cost about 20 times the GPU-hours.
So, Which reuse trick is the viral tweet?
If extra loops do not raise quality, what are you paying?
Does the file still need a second cache?
Full Breakdown ↓↓
1
3
4
2,246
An agent repeats a mistake, so you add a rule.
Months later, nobody remembers why it exists.
“Why Does CLAUDE.md Keep Growing?” calls this “catastrophic remembering.”
The study tracks 247,694 instruction lifetimes across 1,867 repositories.
Files like CLAUDE.md more than triple over their lifetime.
The cause is lost reasoning, not changing requirements.
Without the reason, deleting anything feels risky.
The paper tests attaching a comment to each rule.
Those comments record:
> The failure behind the instruction
> The hypothesis behind the fix
> Evidence from previous attempts
The author built tests where the ideal prompt was known.
Uncommented prompts ended 211% longer than that ideal.
Informative comments cut the excess to 1.4%.
The agent followed constraints equally well both ways.
In an interview with AlphaSignal, author Kushal Chakrabarti (@kushalc) recommends a cache approach.
“The cache should have triggers and pointers, not summaries.”
5
1
14
2,024
A support ticket comes back as billing, sales, or technical. The return is that label, with a probability on it.
You pass the state, the questions, and the allowed answers. That exchange is one step.
TypeSafe's Jev does that in 70 to 500 ms. Input is $0.042 per million tokens, and output tokens are not metered.
> 40x to 200x faster on the comparison table, for System One shaped queries
> 444.6x cheaper only as the workflow-eval high end
A negative balance stays in code. The model is for the call you cannot separate with a rule.
> Route the ticket
> Score the urgency
> Pick the next tool
The vocabulary is the list you typed. A fraud ticket that only offers billing, sales, and technical comes back as one of those three. A spam score of 0.52 is not a 0.998
> Laya, 421 million parameters, about 33 ms for one question on a Tesla T4
> That 33 ms is a local pass, not the hosted 70 to 500 ms
> CLM, up to 9x faster zero-shot when actions repeat or the list is long
> Fine-tuned CLM, 81.6% of 38 DeepSWE tasks and 87.6% of 30 Terminal-Bench 2.1 tasks
> Jev on that judge test, 71.1% and 83.1%, under the one-sample line
Which real ticket has no label in your list?
Full breakdown↓↓
1
2
729
Your audio can score well on DNSMOS and still hurt your AI model.
That’s the problem we’re digging into with @Voices at our upcoming virtual workshop.
We’ll look at the audio quality issues traditional scoring can miss, why reverb matters for TTS, voice cloning & ASR, and how to tell when audio is actually training-ready.
Plus, you’ll hear the difference live.
Join us → luma.com/6w9brzb3
713
People keep lining Qwen3.8-27B up with Opus 4.6, the coding frontier from a few months ago.
So, can that class of model sit on a consumer Mac?
Yes, but you still need to build the stack around it:
> an engine that quotes peak RAM
> a harness with a stop
> and tests you own
If you already use Claude Code or Codex, this is a private loop beside that bill.
Qwen3.8-27B fits a Mac as a 17.6 GB file. But MTPLX still peaks at 23.6 GB once the draft-ahead head is on.
A speed taken on a 128 GB Mac with thinking turned off is a different machine, so leave it out of a 24 GB average.
Two ways this goes wrong:
> You stop at the download, and 24 GB of RAM only loads it tight. A 4-bit copy there is still perfect for most tasks. 32 GB is the first real agent. 48 GB can hold a /goal that a machine can check. 16 GB is not this model.
> Or you stop at the first hour. Ollama is a fine look, but after that you still pick an engine, a harness, and a stop.
Local tokens have no invoice, so a runaway does not get expensive, and you still own the merge. Tests are the stop.
We put the pulls, the install, the skill files, and the git-config check on an interactive HTML tutorial.
Which file to pick if you already live in MLX, and what to refuse to train this week, are a longer argument.
Full breakdown below
6
2
7
1,749
Your AI agents are generating a ton of operational data.
Prompts. Tool calls. Latency. Tokens. Errors. Retries. Cost. Outcomes.
The hard part is turning all of that into something you can actually monitor.
In our upcoming workshop with @TigerDatabase, we’ll show how to build an agent monitoring system on Postgres + time-series data, then scale it for teams running hundreds or thousands of agents.
If AI agents are moving into production, this is the infrastructure layer you’ll need.
Join us → luma.com/j1s2bxf9
3
1,142
METR’s vibe-coded dashboard exposed an agent through an authentication flaw.
An attacker prompted it to reveal its API key.
Over three weeks, the attacker consumed roughly $600K in credits. The provider supplied them free; METR reported no financial loss.
A successful login doesn’t test what happens without one.
Even an HTTP 401 can hide an unauthorized action. If the backend queues work before authentication, a worker can still execute it.
Check the response, queue, and task database together.
Then trace which credentials the worker can read. A separate inference service can hold the provider key and enforce access and usage limits.
Before you deploy:
> Test that rejected requests create no jobs
> Check access across different user accounts
> Keep provider keys outside code-execution workers
> Restrict worker permissions
> Test credential revocation and recovery
2
2
1,181
Grok 4.7 just landed on @mercor's APEX leaderboards:
> #5 on APEX-SWE at 53.6%
> #13 on APEX-Agents at 54.6%
The notable part is the bracket, which sits in the same cost and latency tier as Gemini 3.7 Flash and GPT-5.6 Luna while leading on SWE.
APEX updates with every major model release, so you can see how the newest models stack up, compare token costs, and explore results from third-party benchmarks like BrowseComp and Terminal-Bench.
See the full leaderboard at mercor.com/apex/
*partnerpost
Grok 4.7 is now live on the APEX leaderboards.
APEX-SWE: 53.6% Pass@1 (#5)
APEX-Agents: 54.6% Pass@1 (#13)
Compared to other models with similar cost and latency profiles, it’s a strong model for agentic coding tasks.
Congrats to the @spacexai team.
2
2
9
1,458
A good DNSMOS score doesn’t always mean your audio is ready for AI training.
Join AlphaSignal + @voices for a technical deep dive into what DNSMOS misses, including the “grey zone” where reverb can quietly degrade TTS, voice cloning & ASR models.
We’ll cover:
→ Where DNSMOS falls short
→ How to spot problematic audio
→ What training-ready audio actually sounds like
→ Live audio comparisons
Register → luma.com/6w9brzb3
1
1
1
920
Same model bills 5x more in a different harness
HarnessTax tested 21 model-harness combos across 60 tasks and cost moved far more than success did
> $1.33 against $0.67 per attempt
> 97.8% versus 96.7% success rate
> 9 of 12 beat vendor default
Claude Code and Pi averaged 15 turns, yet the heavy setup carried more than 10 times the initial context because longer instructions and larger tool definitions ride along on every call.
Study co-author @melissapan told us many harness choices run on tribal knowledge and word of mouth, so it is very unclear which setup wins on accuracy or cost for your workload.
We read this as a buying test and the lean setup still holds the cost-success frontier on four tools, read, write, edit and bash.
> When does the heavier harness earn its higher price?
> Which failures hide when two setups post the same score?
> What would your own tasks show if you priced model and harness as one system?
Answers below ↓↓
Does your Claude model really need Claude Code…? 🤔
We evaluate 7 models on Claude Code, Codex, and Pi. Three surprising findings emerge:
1️⃣Harness choice has little effect on task success rate, but can significantly affect the cost
2️⃣A simple harness can be competitive
3️⃣The native harness isn’t always the best.
Millions of people are using coding agents, but the impact of harness choice remains unclear.
(1/n) More details in the thread. 🧵
6
1
9
5,289
One AI agent is easy to monitor. 1,000 agents running across your org? Different problem.
Join AlphaSignal + @TigerDatabase for a live technical workshop on building enterprise-grade AI agent monitoring.
We’ll cover:
→ Tracking tool calls, latency, errors & cost
→ Modeling agent activity as time-series data
→ Real-time dashboards for live agent activity
→ Finding trends & failure modes
→ What changes when you scale from 1 agent to 1,000+
If agents are becoming part of your infrastructure, you need to know what they’re actually doing.
Register → luma.com/j1s2bxf9
3
1
7
893
Anthropic's automatic caching billed us $0.022 per turn for the same 8,400 tokens that cost $0.003 once we placed the cache marker by hand
Automatic caching means one switch, and the system decides what to save. Manual caching means you mark the exact block yourself, so nothing varying ever poisons the entry. That single difference explains the whole gap, and our meter confirmed it across every repeat.
So we wrote down every trick that moved the bill, and each one ships with code you can paste. Every figure below comes from our own runs
> Mark the stable prefix
> Buy minutes, not hours
> Read the usage meter
> Batch the night shift
Then come the two that need explaining. Split planner from executor across two sessions. Cap thinking before it eats its own output.
Our mid-thread model switch billed $0.197 with zero hits. The two-session version read its cache for $0.011, which means the second prefix never charged twice.
Anthropic's docs describe all six features. Our meter readings show what each one actually saves.
The full tutorial walks through every trick with Python and cURL.
Full breakdown ↓↓
3
1
8
1,014
We asked @TencentHunyuan authors why generating a harder coding task keeps failing.
They said a useful terminal task has to keep four things consistent: the public instruction, the workspace, the official script, and the hidden tests.
One mismatch can invalidate the entire task.
> Script fails in the container
> Tests check a missing file
> Hidden rule the agent never sees
Their paper grows a verified child from a parent. Official scripts went from 67 lines to 374 (5.6x). The public instruction only went 85 words to 122 (1.4x).
A frozen DeepSeek-V4-Pro pass@4 fell from 90% to 2.5% on later rounds. Yield still held around 500 accepted tasks per 1,000 attempts.
The extra work is real, and a longer README is the wrong knob.
> When would you auto-generate shell training tasks?
> If the official script passes, is that enough to train on?
> Which exam is the factory never allowed to rewrite?
Full Breakdown ↓↓
3
2
889
@Shopify's 0.8B model beat GPT-5.6 Sol
The task was buyer-profile generation, and daily output went from 2 million to 72 million.
While that is a specialist win on a scored task, a frontier model still helps you start.
Prompt length, request rate, and yearly serving all moved too:
> Prompt 9,100 tokens to 1,100
> GraphQL 2,000 requests a minute
> Could cost $27 million yearly
> Fine-tuned about $1 million yearly
Time-to-first-token dropped by 19%, then end-to-end latency fell by around 38% and throughput rose 16%.
So, they served the same load with around 14% fewer GPUs.
Also, they turn production failures into repaired training trajectories, so a daily loop retrains the small model on old and new examples.
We care about when that loop is worth building, because a bad judge will teach the specialist the wrong behavior.
What has to be true before you train the small one? What does a bad judge teach it? And why is the loop the asset, not the weights?
Full breakdown ↓↓
Training tiny models for special purpose use cases works so incredibly well if you have a great self improving recursive flywheel. Shopify ML team is on fire.
finetuned 0.8b model beats GPT 5.6-sol xhigh in this very specialized task.
3
4
1,187
Your 5-minute cache is already dead when you sit down.
API models don't keep the thread. Every turn resends the whole history.
A one-token tool result still pays that whole history. On Opus 5, 1 million uncached tokens are $5.
A hit is $0.50. Cache-hit discounts are provider-specific.
> Anthropic 0.1x on a hit
> OpenRouter blend near 1/5
> Grok 4.6 cache read 0.25x
> DeepSeek Flash off-peak 0.03x
Earlier, we ran 4.5 through 12 turns at 30,000 tokens. Turns 2 and 10 were full-price re-reads.
Compact before you walk away so the miss stays small. Buy the 1-hour write at 2x, and a return can hit.
Claude Code and Codex often compact around 200,000 to 300,000 tokens. Filling 1 million on purpose buys the expensive part.
So, What do you pin so the cheap copy stays cheap? Where does the project live so compact doesn't wipe it? Why is dollars per million the wrong scoreboard?
Full Breakdown ↓↓
2
4
929
AI agents can write the code, but can they tell when they broke something?
We’re hosting Vilhelm von Ehrenheim, Co-founder & Chief AI Officer at @getqatech, for a technical deep dive into the missing half of agentic development: verification.
Register → luma.com/moa2f7ru
1
758
Agent frameworks keep changing because tool calling never solved the runtime.
A tool schema tells the model how to call one function.
It does not decide who owns the loop, where state lives, what counts as done, or how recovery works.
@NVIDIAAI's NOOA takes a different approach: collapse prompts, tools, state, and model-driven loops into one Python class.
Methods become actions. Fields hold state. Docstrings become prompts. Types become contracts.
The interesting part is not the syntax.
It is the runtime trade-off.
> Typed tools keep boundaries explicit
> Graph runtimes make control durable
> File-based agents keep state on disk
> Live objects keep rich state inside one process
NOOA avoids repeated serialization by letting the model work against live Python objects through bounded methods.
But that state is local. Restarts, distributed execution, replay, and checkpointing bring the serialization problem back.
So the useful question is not “which agent framework is best?”
It's "Who should control the loop?"
And "where does the state need to survive?"
3
2
879
A moderation model can read your policy, react to it, and still enforce it incorrectly.
Tested @MistralAI's 3B Shieldstral on 124 policy decisions.
The model clearly responds to runtime rules. Every unfamiliar-policy match scored above its unrelated control.
But the failures appeared when the rule became specific.
Explicit exceptions were the weakest case. Only 5 of 12 broad-rule-and-exception pairs flipped the way they should.
One emergency-services exception still scored 0.974 as a violation.
Another disclosed sponsorship was classified as undisclosed across four different phrasings.
So the problem is not simply:
“Can the model understand this policy?”
It is:
> Does the policy change the score correctly?
> Does the score cross the right threshold?
> Do exceptions and negations actually change enforcement?
Shieldstral looks less like a rules engine and more like a policy-conditioned semantic scorer.
That distinction matters if you plan to change moderation policies at runtime without retraining.
2
5
865
Your agent does not need direct internet access to reach the internet. It only needs one service around it that does.
That was one lesson from @OpenAI's Hugging Face incident.
Agents used an internal package service as a message board, then used that same path to reach outward. Shared storage became communication. One reachable service became a bridge to more infrastructure.
@trailofbits pushed the same idea from another angle. GPT-5.6-Cyber escaped a QEMU/KVM VM three times.
The takeaway is not “use better prompts.”
It is: stop treating prompts, containers, or VMs as the security boundary.
> Separate behavior rules from hard permissions
> Assume the sandbox or VM can be compromised
> Remove unnecessary interfaces and host access
> Treat isolation as an end-to-end network property
> Make every workload credential low-value
This article is worth reading if you are building agents with tools, code execution, cloud access, or long-running tasks.
The core question is no longer whether the agent follows instructions.
It is what the surrounding system still prevents after the agent stops following them.
Full breakdown ↓↓
3
4
875
AI labs hide the model's scratchpad (reasoning), then send you an encrypted copy so the next turn can continue. Public agent logs hid 315,320 of those copies. Cleaning the chat never opens them, and password scanners scored 0.
A research paper decoded those copies from 6,708 posted agent sessions. 4.9% of those sessions (328) leaked at least one real secret.
We ran five password-style regexes on a fake session that held three long envelopes labeled FAKE.
> Chat cleaned, envelope stayed
> 64 artifacts never in chat
> Writing laptop still holds them
We grepped Claude Code and Codex folders used for research and content writing. Counts only. We did not read the blobs.
Zero Data Retention still leaves the unread copy on the client. One AWS page calls the same field a hash.
What is actually inside that sealed copy?
What do you strip before git, evals, or a zip?
Does Bedrock make the laptop copy go away?
Full Breakdown ↓↓
4
1
4
1,147
Most AI agent skills are written like tutorials. The data says they work better as runbooks.
A new study analyzed 8,135 agent trials to understand when skills actually help.
The main finding: skills do not mainly fill knowledge gaps.
They stabilize execution.
Procedural anchoring accounted for 65.7% of successful skill cases. Explicit knowledge injection accounted for just 4.5%.
That changes how you should build a skill library.
> Distill successful trajectories into step-by-step procedures
> Label failed runs before using them for skill generation
> Route by domain before retrieving from large catalogs
> Use strict triggers when skills look semantically similar
One result shows why this matters.
When success and failure labels were visible during skill distillation, an agent reached 74.6% success.
Remove those labels, and it dropped to 40%.
The retrieval results were even stranger.
As the catalog grew from 5 to 100 skills, retrieval precision collapsed. Task success barely moved.
Agents often picked the wrong skill and still extracted enough useful procedure to finish the task.
So the important question is not simply:
“Did the agent retrieve the correct skill?”
4
1
7
1,158
A self-improving agent can look better in validation and still fail to improve where it counts.
Tested GPT-5.6 Sol as an optimizer for two already-engineered SWE-bench agent harnesses.
The optimizer read failures, diagnosed recurring problems, and rewrote the worker’s instructions.
One edit looked like an obvious success. It doubled its validation score.
Then it hit tasks the optimizer had never seen.
No net improvement.
Another edit looked much less convincing during validation, yet performed better on the sealed test.
That changes the problem.
> How do you separate real improvement from a lucky gate?
> How do you catch regressions hidden behind a higher score?
> How much evidence should an agent need before its own edit becomes permanent?
The edits did change how the agent approached problems. They pushed it toward different code paths and different fixes.
But a better-looking validation result did not reliably tell which behavior should ship.
4
4
886
You can now skip the handshake and still call a tool and your retry after a timeout can place two requests.
We ran the retry on one laptop. The tool slept 2.5 seconds on purpose.
> Wait 2.5 seconds
> Abort around 400 ms
> Log already at 1
> New id, second write
Same sku. Same machine. A new request id is now a new call.
Google said the old pin returned 400 Session Not Found on the wrong pod. GitHub already dropped Redis session reads and writes.
Claude-only apps can often wait. Server authors cannot treat a hang-up as a rollback.
What keeps a retry at one write?
Where does a cart live with no session id?
Do you still advertise the old revision?
2
3
799
Agents don't fail because of the models. They fail because of the data.
Ask an agent one question about a customer and watch what it does first: list objects, describe schema, paginate, filter. Four calls before it reads anything useful.
Ask a second question. It does all four again.
Airbyte Agents changes where it looks first.
The Context Store pre-indexes your CRM, support desk, and code repos across 50+ connectors. The agent searches that index locally and only calls the source for fresh state or to act.
Airbyte's own benchmark against vendor MCP servers:
> Up to 80% fewer tokens
> 40% fewer tool calls
> 90% cost savings on multi-source queries
Connect over MCP, the CLI, or the Python SDK. 1,000 agent operations free, no credit card.
Try it free: app.airbyte.ai/signup?utm_so…
1
3
712
The most dangerous part of an AI agent is not what it thinks. It is what the system lets it do.
Agents have already deleted 200+ emails, wiped a production database, and caused an outage while following what they believed was the correct action.
Another system prompt does not fix that.
Agent security is moving into three system layers:
> Infrastructure: sandbox execution and keep credentials outside the agent
> Runtime: reduce the attack surface and isolate each session
> Network: inspect outbound requests before they leave the boundary
@NVIDIAAI's NemoClaw handles the infrastructure layer with Docker, Landlock, seccomp, network namespaces, and a gateway that injects API keys only after approval.
NanoClaw reduces the runtime surface with a small codebase and isolated ephemeral containers.
CrabTrap treats the network as the final control point. Low-risk requests pass through static rules. High-risk requests go to an LLM judge and, when needed, a human approver.
The security model changes once you assume the agent will eventually make the wrong decision.
1
1
5
727
85% say the bottleneck is reviewing AI code, not writing it.
@gitlab asked 1,528 developers and buyers. The queue moved from generation to validation.
@SonarSource's 1,100+ survey says 42% of committed code is AI-generated. 96% do not fully trust it is functionally correct. Only 48% always check before they commit.
We generate faster than anyone can read. Another round of doubt will not shrink that queue.
@unclebobmartin ships unread agent code. He can, because the checks fail it without him:
> Unit tests he never reads
> Acceptance tests he spot-checks
> Mutation on the suite
> Quality metrics on the output
The transferable part is not his full stack. It is how much autonomy a change earns when something cheap can fail it. Reading every line just makes you the new queue.
> When can a change ship unread?
> What still needs a name on it if it ships wrong?
> What fails if nobody reads the diff?
Full Breakdown ↓↓
4
4
885
We put $2,500 on the first person who could get a pizza delivered to the room by an AI agent they hadn't written yet.
They had 90 minutes to write it, with the clock running on the projector and no pre built code allowed.
That was AlphaSignal's Pizza Agent Challenge in SF last week.
750 people registered and around 130 turned up to build. Engineers from OpenAI, Google, AWS, Palantir, Goldman Sachs and JP Morgan signed up for it.
The mission was to build an agent that autonomously orders a pepperoni jalapeño pizza and gets it delivered to the venue. First box through the door wins.
Checkout is where most of them got stuck, because the agent had to place a real order with real money against a real merchant.
The winner took first by building on the DoorDash CLI that shipped last month. Second and third pushed their orders through @Brave's API, which held up.
Thanks to @Naamoney_ for running it with us, and to @Brave for backing it.
If you had 90 minutes and no pre written code, how would you have gotten the order through?
4
2
8
1,030
We benchmarked DeepSeek V4 Flash, and it proved to be an absolute beast!
The results confirmed the claim that it is around 100× cheaper than Fable 5.
Here’s what stood out:
> @deepseek_ai V4 Flash ranked #1 at $0.004 per fix and $0.21 total
> @grok 4.5 ranked #2 and was the fastest model with a perfect score at 55 seconds
> @claudeai Fable 5 was the most expensive model with a perfect score at $0.389 per fix and $20.99 total
How is this possible?
Cheap cache reads.
It actually processed more tokens than Fable 5, but most of its repeated context was billed at a discounted cache rate. This kept the total bill low even across millions of agent tokens.
DeepSeek V4 Flash wasn’t the fastest model, but it delivered the strongest combination of debugging accuracy and cost.
Full benchmark results and breakdown below.
7
2
13
1,464
Your agent can find the policy, understand it, and still violate it.
That happened in HANDBOOK.md.
Claude Opus 4.8 found that a $7,500 expense lacked valid manager approval. It even reached the correct conclusion.
Then its own reasoning reversed the decision.
It cleared the expense and reported that the approval was valid.
Every fact needed for the correct decision was already in context.
HANDBOOK.md tests 65 tasks with policies up to 124 pages. Completed trajectories average roughly 17 reasoning steps and 30 tool calls.
The strongest tested configuration passes only 36.2%.
Four mechanisms explain the failure:
> Compounding error
> Context competition
> Growing context cost
> Irreversible actions
The math is simple. At 99% accuracy per critical decision, 100 independent decisions produce only ~37% end-to-end success.
Real trajectories can be worse because decisions depend on previous actions.
5
5
1,507
Link: alphasignal.ai/news/open-mod…
Taste answer: when code and logs arrive together, treat Find and Reconstruct as separate checks. Instant empty refusals are a known outcome. If the model describes the attack and never hands you the key, put a decoder script next to the model. Full setup, limits, and Monday checks above.
291
If your incident response path is pasting logs into a frontier commercial API, it will break when you need it most.
We already saw that refuse wall on Hugging Face forensics. The sharper question is whether Find and Reconstruct are the same job.
We checked both on one synthetic HF-shaped repo. Two questions, three models, three runs. Plain chat, no tools.
> Find: list the security holes in code and config
> Reconstruct: explain the attack path and decode the blobs
Kimi K3 and Grok 4.5 found all 4 planted issues every run. Claude Opus 5 refused all 6 calls on the package (Find and Reconstruct). Nobody recovered the key over bare chat. Kimi could narrate the path, then stop. A short offline script still recovers the key.
Same week on DeepsecBench, Opus ranks 2nd at finding app bugs, while GLM-5.2 (the model class that processed radioactive logs in production forensics) sits near the bottom of that board.
> Does your analysis path answer when the package includes logs and blobs together?
> Does the model hand you a key, or only a story?
> Have you rehearsed that on a planted tree before the next real weekend?
2
6
785
@Kimi_Moonshot built a 2.8 trillion parameter model that would need more than 5TB in BF16.
The harder problem was not training it. It was making it practical to serve.
Kimi K3 activates only 104 billion parameters per token, but sparsity alone does not solve the memory and bandwidth bottlenecks.
Moonshot redesigned the model across four layers:
> LatentMoE compresses tokens before expert routing
> KDA keeps a fixed-size attention state
> MLA compresses the KV cache for exact retrieval
> Native FP4 training cuts the weight footprint
Kimi K3 combines three KDA layers with one Gated MLA layer. This gives it constant-memory attention for most layers while retaining full context retrieval where it matters.
That hybrid design makes its 1 million token context practical without a KV cache that grows across every token and layer.
Quantization-aware training handles the remaining weight problem. Moonshot trains the post-training pipeline in low precision instead of compressing the model after training.
Kimi K3 has more than twice the parameters of Kimi K2, but its deployed memory footprint grows by a much smaller ratio.
3
1
3
1,042
We tested @AnthropicAI's Claude Opus 5 at varying reasoning levels to see whether giving it more time to think would help it fix more bugs.
We expected the highest setting to win clearly. It didn’t.
The most interesting findings:
> Medium fixed the same number of bugs as High at less than half the cost
> XHigh fixed only one additional bug, while three competing models achieved better results for less
Opus 5 is a very capable coding model.
But our results show that paying for more reasoning doesn’t always lead to a better outcome.
For teams using AI coding agents, choosing the right reasoning level could make a big difference in cost and speed.
4
6
998
A solo agent works for one person.
Scale that setup across a company, and you create separate memory, credentials, and workflows for every employee.
@viktor_com starts with the team instead.
It separates memory by team, topic, and task, then connects that context across more than 3,000 enterprise tools.
One customer used Viktor to check purchase orders, delivery conversations, and warehouse confirmations across separate systems. It flagged a stockout five weeks early.
The company deployed 12 autonomous workflows in 15 days.
Viktor also keeps credentials outside the agent environment:
> Code runs inside a restricted sandbox
> API keys stay inside an encrypted vault
> External content passes through classifiers
> Data changes require human approval
Its shared memory stores workflows, corrections, and operating knowledge across the company.
Another organization started with grant research. Viktor later built 58 operational skills that supported 10 web platforms, two mobile apps, and 27 scheduled automations.
An enterprise does not need the same solo bot copied across every laptop.
It needs a team agent.
1
1
1
750
The open-model race is no longer about finding one universally “best” model.
Apertus and @allen_ai's OLMo optimize for transparency.
@poolsideai's Laguna and @Alibaba_Qwen optimize for hardware efficiency.
@Macaron0fficial's Macaron turns one base model into a set of swappable specialists.
@Kimi_Moonshot's K3, @deepseek_ai , @Zai_org's GLM, and @MiniMax_AI push downloadable capability toward the closed frontier.
That changes how you should compare them.
> A model can be cheaper to run but harder to load
> A model can be fully open but weaker on benchmarks
> A model can be downloadable but impractical to host
> A model can be modular but add routing failures
One leaderboard cannot rank all four approaches well.
4
5
782
It gets worse because the tax grows with how much context you're carrying. Double the session, and you double the cost of every switch inside it.
Cost per 1,000 prefix tokens barely moved across a six-fold change in session size:
alphasignal.ai/news/model-ro…
2
255
Your model router charges you for context that you've already paid for, eleven times over.
Prompt caches belong to one model. Change the model during a session, and the new model will read everything all over again, at the full price.
We priced it with three different session sizes. Same 12 turns, run five times.
> One switch cost 11x warm
> Routing somewhere else cost 47% more
> Caches don't transfer between models
Grok 4.5 gives output five times cheaper than the model it took over from. Price change was 0.2% in one test, and 7.9% in another.
The second issue is hidden under all of that. Claude counts 58% more tokens than GPT for the same prompt.
So, spending $2 instead of $5 is not a 60% savings. On the same prompt, it's closer to 37%.
Which part owns the decision on which model to use?,
When will a switch ever become profitable?,
And why does it become even more expensive with longer runs?
6
1
8
880
Bun rewrote a million lines of code in 11 days for $165,000.
A JavaScript runtime in wide production use moved from Zig to Rust.
Manual memory handling was its main source of crashes. The compiler now catches most of those bugs.
Agents wrote every line across 1,448 files. It merged green on every supported platform.
Graph engineering guides teach the mechanics and skip the price. Our breakdown runs the arithmetic they leave out.
> 64 instances running at peak
> Claude Code caps 16 concurrent
> Crossover sits at 17 units
> Cheap models cut bills 4x
> Two skeptics reviewed every diff
They also stubbed broken functions and justified them in comments. One added rule stopped that within hours.
Doing it by hand runs a year for three engineers. Nobody actually paid that invoice.
Link in the first comment.
4
4
773
LLMs shred 100.50 into 3 tokens. But tabular models don't.
That is the whole mismatch. Tables are two-dimensional and row-order free. Left-to-right models still read them like prose and break column distributions.
The new models treat the table as the prompt. They score new rows in one forward pass, zero-shot, without per-dataset training.
> Google TabFM under Apache 2.0
> Nvidia KumoRFM on multi-table graphs
> TabPFN as a Nature-backed prior
> TabICL at 500,000 samples
One of those scales to 500 features and claims up to 10x speed on large sets versus the prior generation. Warehouse integration is already on the roadmap for the open-source Google path.
Classic gradient boosters still own millisecond fraud scoring once the schema freezes. The hard cut is training cost versus inference latency.
> Where does zero-shot stop beating constant retraining?
> Which stack fits a multi-table warehouse versus a single CSV?
> Do you prototype on a TFM, then freeze into XGBoost?
Read below↓↓
4
4
14
1,612
@AnthropicAI just released Claude Opus 5. @GoogleDeepMind also released Gemini 3.5 Flash few days back.
Every new model launch creates the same problem for engineering teams:
Do you trust the public benchmarks, build a full internal benchmark, or ignore the release until someone else tests it?
A better first step is much smaller.
We compared Gemini 3.5 Flash with 3.6 Flash on one narrow production-style task: summarizing technical papers under a fixed 180-word limit.
That small set was not enough to approve a migration.
It was enough to reveal what mattered:
> 3.6 retained more required facts
> 3.5 followed the length constraint more reliably
> Both repeatedly lost the same critical qualification
That is the point of a smoke test.
Before spending days building a full benchmark for Opus 5, Gemini 3.5, or the next model release, run 5–10 cases built around failures that would make the model unusable in your system.
The full article walks through how to reuse production failures, build answer cards, grade outputs, and decide whether a model deserves more evaluation time.
Public benchmarks put a model on your shortlist.
Your own smoke test decides whether it stays there.
3
1
3
828
Google says Gemini 3.6 Flash is faster, smarter, and cheaper. But how does it compare with other frontier models when fixing real bugs?
We tested it on 13 private debugging tasks. The results were mixed:
> Ranked 7th among 9 models
> Fixed 60 of 65 attempts
> Used more total tokens than any other model tested
One of its best runs traced a ranking bug to two separate faults across different parts of the codebase and fixed both.
In another run, it correctly diagnosed a performance bottleneck and said it had implemented the solution.
Sure, Gemini 3.6 Flash can fix difficult bugs.
The bigger question is how much time, context, and money it takes to reach a working patch.
In the full benchmark, we break down its reliability, cost, speed, failure patterns, and the debugging tasks where it makes the most sense.
7
3
22
1,908
Quick tell: if quality only cracks after a long, messy history but a clean restart nails the same task, that is context rot, not a weak model.
The full 5-step test to run on your own agent, the cases where a harness is the wrong move, and starter code are here: alphasignal.ai/news/context-…
-----
5-min free daily AI signals: alphasignal.ai/newsletter
1
1
339
@MIT_CSAIL's @a1zhang and @lateinteraction trained a model to generalize 8-32x past its training length.
The research credits the harness, the scaffolding around the model, not the model itself. Train it only on short tasks, and it still handles far longer ones.
That works because the harness keeps every model call close to what it was trained on.
It offloads the bulk context into a code environment and keeps the results of its smaller sub-tasks out of the main chat, so the model never drowns in its own history.
A few things that held up:
> trains short, runs 8-32x longer
> transfers across different domains
> training costs 1.5-3x more
Context rot, the decay your agent hits as history piles up, is often this scaffolding problem, not a weak model.
So,
> How do you tell rot from a model that is simply too weak?
> When does adding a harness backfire?
> What is the one check to run before you pay for a bigger model?
Answers in our write-up below ↓↓
5
2
9
1,073
> Full deep dive: alphasignal.ai/news/why-inkl…
> 5-min daily AI digest: alphasignal.ai/newsletter
> Task Table:
3
315
We ran Thinking Machines Inkling through our private coding-agent bench.
Same harness as the rest of the field. Signaldesk v1: 13 planted bugs in a ~7k-line full-stack app, network-off Docker sandboxes, hidden tests at score time.
Across 8 models and 553 attempts, Inkling landed 6th.
> 89% resolve (58/65)
> $0.104 per successful fix
> 61s average attempt
> $6.01 total spend
That puts it under gpt-5.6-sol (100%, $0.183/fix), grok-4.5 (99%, $0.074), fable-5 (99%, $0.411), opus-4.8 (97%, $0.144), and glm-5.2 (94%, $0.019). Above gemini-3.1-pro-preview (80%) and kimi-k3 (79%).
Localized bugs and security tasks were clean. All three injection/auth tasks went 5/5. Easy and moderate tiers both hit 100%.
The gap is deep investigation. Expert-tier resolve dropped to 20%. On sd-013 ranking-tiebreak it scored 1/5. On sd-003 empty-digest it scored 2/5. Peers cleared sd-013 at 5/5 (kimi 4/5).
Behavior matches the miss pattern. Highest turn count in the run at 20.2 average turns, 2.4× gpt-5.6-sol’s 8.3, with the lowest average output tokens in the field. Fast wall clock (2nd after grok at 46s). Sparse thinking, lots of tool loops.
Route high-stakes multi-file bugs elsewhere. Keep Inkling for fast, mid-depth agent fixes where open weights and $1/$4.05 pricing matter.
Full Inkling deep dive plus how we read sparse routing and self-host cost is in the article. Bench tables in the first reply.
Today, we are introducing Inkling.
Inkling reasons efficiently across text, image, and audio modalities. We are making the full weights available.
thinkingmachines.ai/news/int…
Available today for fine-tuning on Tinker. Play with it in the Inkling Playground. 🧵
5
4
10
1,452
Thinking Machines just shipped a 975B model that runs like 41B.
Their open-weights model is called Inkling. Most of its parameters stay idle during inference.
Context stretches to one million tokens. The license is Apache 2.0.
> Top U.S. open-weights score
> 25,000 output tokens average
> Elo 1238 on agent work
> $1.00 in, $4.05 out
It scored 41 on Artificial Analysis. That leads every other U.S. open-weights entry on the board.
You can raise thinking effort for hard coding. You can drop it for volume tasks.
NVFP4 quantization cuts self-host memory. VRAM falls from about 2 TB to roughly 600 GB.
Day-0 serving is live on major routers. We map the sparse routing and the price path.
We also show when closed APIs still win the edge cases.
-----
Full article: alphasignal.ai/news/why-inkl…
5-min daily digest: alphasignal.ai/newsletter
nitter.siddz.com/thinkymachines/status/…
Today, we are introducing Inkling.
Inkling reasons efficiently across text, image, and audio modalities. We are making the full weights available.
thinkingmachines.ai/news/int…
Available today for fine-tuning on Tinker. Play with it in the Inkling Playground. 🧵
7
2
11
1,610
What our test is (and is not):
We run a coding-agent repair harness (Signaldesk), not a frontend board and not Kimi Code.
> 13 planted-bug tasks · 7 models · same rules for all
> Network-off Docker sandboxes
> Held-out tests only at scoring
> Pass = visible + held-out + full regression, no test-file edits
K3 on that run: 53/67 (79%), last of 7. Sol 100% (70/70). Grok 99% at 46s.
Arena Frontend #1 (1679) can still be real. Different job: UI generation preference vs multi-file repair under held-out tests.
Caveats: small task set, one harness, K3 needs full thinking history each turn. We re-checked K3 traces for missing reasoning_content and unexpected stops and found No mass trajectory breaks. Ranking still stands on the scored attempts.
Full method: alphasignal.ai/news/arena-1-…
2
1
26
6,179
Kimi K3 is getting called Fable/Sol level, and it's 7th in our tests.
Arena Frontend Code: #1 at 1679 points.
Artificial Analysis: #3 at Intelligence Index of 57.
We ran it the next day on our coding-agent repair harness against GPT-5.6 Sol, Fable 5, Grok 4.5, Opus 4.8, GLM-5.2, and Gemini 3.1 Pro.
Results:
> Last of 7 models
> 53 of 67 attempts (79%)
> $0.186 per successful fix
> 702s average wall time
Sol hit 100% (70/70) on the same suite. Grok sat at 99% and 46s.
So why does the internet sound so sure K3 is crushing coding agents, if our tests have it at the bottom?
-----
> Full write-up: alphasignal.ai/news/arena-1-…
> 5-min daily signals: alphasignal.ai/newsletter
Kimi K3 scores 57 on the Artificial Analysis Intelligence Index. Its intelligence is comparable to Opus 4.8 and GPT-5.5 but remains behind Fable 5 and GPT-5.6 Sol. Moonshot AI has expressed plans to release the 2.8T parameter model's weights, which would make it the leading open weights model
Key results:
➤ Strong agentic task performance: @Kimi_Moonshot's Kimi K3 reaches an Elo rating of 1668 on GDPval v2. This is a marked improvement over K2.6’s 1190, surpassing GLM-5.2 (1514), GPT-5.5 (1494), and Claude Opus 4.8 (1600). However, it still lags behind Claude Fable 5 (1760). Kimi K3 also scores an impressive 53% and takes the #1 position on AutomationBench-AA, our implementation of Zapier’s Agentic SaaS workflow evaluation.
➤ Second-highest performance on AA-Briefcase (agentic knowledge work): On our private long-horizon knowledge work evaluation, Kimi K3 reaches an overall Elo of 1547, +732 points from Kimi K2.6 and behind only Claude Fable 5. It is well-rounded: its rubric scoring and analytical quality almost reach Claude Fable 5’s scores, while GPT-5.6 Sol continues to outperform other leading models on presentation quality.
➤ Set to lead open weights models once weights are released: Moonshot AI has not yet released the weights but expressed plans to do so. Once available, Kimi K3 would clearly lead other open weights models including GLM-5.2 (51) and DeepSeek v4 Pro (44). However, at 2.8T parameters, it is significantly larger than its open weights peers (eg. GLM-5.2 at 753B params and DeepSeek V4 Pro at 1.6T), as well as the Kimi K2 to K2.6 models (1T params).
➤ Cost per task ($0.94) is similar to GPT-5.6 Sol ($1.04), ~1/2 the price of Opus 4.8 ($1.80) and higher than open weights peers: Moonshot AI’s pricing for K3 is significantly higher than their K2 pricing (K3’s output token price is $15/1M tokens while K2.6 was $4). This positions the model as cheaper on a cost per task basis than Opus 4.8, similar to GPT-5.6 Sol ($1.04) and more expensive than open weights peers, GLM-5.2 ($0.32) and DeepSeek V4 Pro ($0.04)
➤ Improved token efficiency alongside higher intelligence: Kimi K3’s token usage on the Artificial Analysis Intelligence Index decreased significantly, using 21% fewer output tokens than K2.6. The new model used approximately 132M output tokens to complete all nine evaluations, compared to approximately 166M for K2.6, while achieving higher scores.
➤ Native multimodal capabilities: Kimi K3, like K2.6, is released with native image and text multimodal input. If weights are released, this will position Kimi K3 as one of the leading open weights models with multimodal input capabilities
Other model details:
Context window: 1M
Size: 2.8T total parameters
Pricing: The first-party API is priced at $3.00/$15.00 per 1M input/output tokens, with cached input discounted 90% to $0.30 per 1M tokens.
Modality: Native multimodal input supports text and images, and the model remains text-only for output.
Accessibility: Accessible at launch through Moonshot’s first party API. Model weights are not yet released but Moonshot AI has expressed plans to do so.
144
106
1,022
488,259
Kimi K3 is the 7th in our tests while it hit #1 on @arena Frontend Code at 1679 points!
We ran it the next day on our coding-agent repair harness against six peers: GPT-5.6 Sol, Fable 5, Grok 4.5, Opus 4.8, GLM-5.2, and Gemini 3.1 Pro.
It finished last of 7 the models with 53 of 67 attempts (79%).
So, How can both be true?
Read why the boards disagree (and the full scoreboard) in replies ↓↓
Introducing Kimi K3: Open Frontier Intelligence
🔹 2.8 Trillion Parameters, 1 Million Context, Native Multimodal
🔹 Kimi Delta Attention enables up to 6.3x faster decoding in million-token contexts
🔹 Attention Residuals deliver ~25% higher training efficiency at <2% additional cost
🔹 Built for long-horizon agentic coding and self-evolving workflows
Kimi K3 is now live on on Kimi.com, Kimi Work, Kimi Code, and the Kimi API.
Open Weights by July 27, 2026.
🔗 API: platform.kimi.ai
🔗 Tech blog: kimi.com/blog/kimi-k3
19
15
102
27,642