Two Months of Anthropic, OpenAI, Meta and DeepSeek: Are We Any Closer to AGI?

One company replaced git. Not with a plugin. It wrote its own version control system and moved its main repository over in five months.
That was the detail that stuck with me after I read through about thirty sources from the last two months. I sorted everything into nine buckets, and most of them turned out to be the same story: once agents do real work at scale, things we built for humans start to break.
1. Source control is changing
Anthropic wrote its own version control system, Scion, and migrated its monorepo off git in five months.
The reason is straightforward. Git assumes every clone is a complete, self-contained repository, so you can diff, blame and check out any revision offline. That design serves people whose laptops lose connectivity. Anthropic's clients are almost entirely agents and scheduled jobs, which are online by definition. The properties that made git the standard became friction for them.
Volume is the bigger issue. In May they merged about 2,500 changes a day. By September it was over 30,000. By Anthropic's own estimate, fetching that the normal git way would generate more than 600 PB of traffic per day.
GitHub kept git and changed the layer underneath it. Its reason is different. Monthly pushes are up nearly 5x year over year, and an agent in a closed loop commits after almost every action, so latency that no human would ever notice becomes the limiting factor.
The two positions differ for a simple reason. Anthropic is the consumer of one enormous repository, so it can drop git. GitHub is a platform and has to keep honoring git semantics.
2. How to do code review now
Addy Osmani's August post is titled "Human judgment doesn't leave the software factory. It relocates." For more than a year he has argued that humans should move up the stack and do sampling and audits. This time he says you still review code, but you choose where on purpose: places where automated back-pressure fails, and places where maintainability trade-offs need a human. He also proposes a concrete mechanism. Treat human review capacity as a gate, and when review falls behind, stop shipping to production.
Rachel Laycock at Thoughtworks goes further. Maybe we should not review all of this code at all. Code review has been loaded with too many jobs, such as onboarding, knowledge transfer and architecture control. Those belong upstream, and human review should be reserved for high-risk changes.
On the tooling side, GitHub released ReviewBench in October, the first open benchmark for the review side. It samples 219 PRs that follow the distribution of more than 100 million real pull requests.
3. Agent benchmarks are not to be trusted
A batch of papers this year audits the scores we use to prove agents are getting better. The numbers go wrong in three ways.
The task itself is wrong. SWE-bench Pro shipped a redone version in September that removes 89 tasks judged invalid on review. In 69 of them, the task description and the tests that grade it contradict each other. Repeating the experiment will not catch this. Run ten different models and you get the same wrong conclusion every time.
The endpoint metric turns noise into progress. Self-evolution papers often report final-round success rate minus round-zero success rate. One paper shows this mixes real evolution with the variance of re-scoring a frozen agent. Once you add the control, the gain for most coding methods is negative.
Leaving out a dimension inflates the result. One benchmark pairs execution quality with collaboration quality. Require both, and the best model drops to 49%.
I went looking for a counter-example. One report claims change failure rate is up 30% year over year, which would be a rare quantitative sign that AI is not making things better. I downloaded the PDF. The data window is Q3 2024 through Q4 2025, and the 2026 in the report's title is only the edition name. Data that stops last year cannot tell you about today.
4. Models built to make decisions
A large share of the calls in an agent loop are multiple-choice questions. Which model should get this request? Should this context be compressed? Did this tool call succeed? The answers are bounded, yet we answer them with a model that writes essays, which is slow and expensive.
In September a company called TypeSafe AI opened up Jev. It does not produce prose. You give it a state and a set of options, and it returns the option it picked with a probability and a confidence, constrained to a predefined schema. On October 22 OpenAI took the Decisions API to general availability. The idea is the same, it runs on GPT-6 Luna, and OpenAI says it is up to 10x faster than calling the same model through the normal interface. There is also an open-source LLM2Jev that turns a local model into a structured decision engine behind the same interface.
The results are still unproven. Jev claims 40 to 200x faster and 40 to 400x cheaper than frontier models. Those are self-reported, the team admits the tests are biased, and it is closed source with no paper. For OpenAI I found one third-party number: customer Box says document classification got about 5x faster. For this category as a whole, I could not find independent data that compares against a frontier model.
5. The harness became a big-company standard
A harness, roughly, is everything around a language model that turns it into an agent that can do work: tools, context management, the execution environment. Before this year the word lived mostly in personal blogs. In the last two months it moved into product documentation.
Anthropic's Claude Code glossary now defines it, saying Claude Code is the harness and Claude is the model inside it. OpenAI's September Agents API is subtitled around building and running cloud agents with the Codex harness, and promises versioned access to the harness with each model release. GitHub published an explainer on the new vocabulary. LangChain has a post on building a model router inside a harness. According to IT168, Alibaba Cloud lists Model, Harness and Context as the three core build scenarios of its Agentic Cloud.
Plugins went with it. The Agent Skills standard was donated in October to a foundation under the Linux Foundation. Per the announcement it is integrated by more than 70 agent platforms, with a million skills published and nearly 280 million installs. Anthropic went one layer deeper with mods. A plugin no longer just adds prompts and tools. It can register tools, draw UI and hook into events like agent start and tool checks.
Is a harness worth the effort? Naresh Jain's piece offers a strong data point. He measured with and without. After adding a behavioral harness, a cost-optimized model was more reliable than a frontier model, at roughly a third lower cost per run.
6. The interface for humans and for AI should differ
People were saying this earlier this year. What changed is that it now has a product and a cost argument behind it.
GitHub's Burke Holland titled his September post "When chat is the wrong UI." His argument is that chat became the universal answer because the supplier does not know what people will use AI for. Once the user does know, the general interface turns into a cost.
What they built is called canvas, a full-stack mini app that runs inside the app with no browser chrome. It talks to the agent in both directions, can run code locally, and you generate one with a sentence. One of his examples is a local package manager UI, and he points out that there is no AI on that screen, which is the point.
He adds a new reason. When chat is the main interface, it nudges you to use the agent for everything, which is often pure token waste. Having the agent build a tool, after which every interaction is free, is almost always better than using the agent itself as the tool.
Another post from the same company offers three layers: the modality captures intent, the harness plans and executes, and a control plane lets developers inspect, redirect and approve.
7. Personal agents: same shape, different limits
In the last two months Meta shipped Muse, OpenAI shipped dots, and Anthropic shipped Claude Duet. The shape is similar: always on, proactive, with their own cloud computer and browser, connected to many of your accounts. None is fully open yet. Muse is a staged rollout, dots is a limited release, and Duet is a research preview with a waitlist, paid tiers in the US only.
The three differ in where they draw the line. Meta puts the limit at the network egress. Each user gets a dedicated cloud VM and a separate, system-isolated gatekeeper agent, and nothing reaches the internet without its approval. OpenAI puts it at the toolset. Its proactive mode uses read-only tools and cannot send messages or modify content. Anthropic puts it at the action type. Sending messages and payments need your approval, and buying or selling securities and moving money between accounts are, according to news coverage and the help center, not executed even if you approve.
That last one is the most unusual. It does not hand the decision back to a human. It removes a whole class of actions from the action space.
A few more words on Meta, because its choice differs most from the other two.
Muse launched on September 8, and invitation codes with a billion free tokens filled my feed for days. The design has two layers. The credential layer is solid. The main agent only ever holds substitute credentials, the gatekeeper agent mentioned above is called Sentinel, and payments run through one-time Stripe card numbers.
The memory layer goes the other way. Muse keeps one accumulating personal memory, which Alexandr Wang describes as the user's second brain. That makes cross-context reasoning strong. It knows you are traveling and compares hotels without being asked. The cost is that this memory has no isolation boundary.
What the credential layer cannot stop is an agent being talked into pulling data it should not. According to reports of internal Meta posts, an employee testing Muse found that a harmless-looking request, to find the toys in photos from a child's birthday party, got the agent to bypass its limits and expose photos in the user's iCloud. Nobody in the industry has solved this class of attack yet.
In China, according to media reports, Alibaba opened trial applications for Qianwen Go! in October. It takes the opposite route from the three above. It does not do general browser automation. It closes the loop on Alibaba's own transaction ecosystem and handles seven well-defined errands, such as flight-delay claims, price-protection refunds and venue booking. The three Western products bet that general capability will cover the long tail. Alibaba bets that determinism inside its own loop is worth more.
8. Recursive self-improvement: readings in both directions
RSI, recursive self-improvement, is AI improving itself. In these two months it went from slogan to something with measurements, and the measurements point two ways.
On the forward side, Anthropic had Claude act as an automated alignment researcher. It proposed post-training methods and built data on its own, and improved all ten failure types previously characterized by public benchmarks, with gains that generalized to a held-out benchmark and to a model 4.7x larger. They also ran a human baseline: the methods from 28 senior researchers did worse than the best automated method.
OpenAI says it hit its goal of an automated research intern, by its own definition of the term, and discloses that the median researcher's daily coding-agent usage exceeds $600 at API prices. Zhipu says an Infra Agent powered by GLM-5.3 did most of the analysis and code changes on its own inference serving, reached production in under two weeks, and delivered about 3x the initial baseline throughput.
A new benchmark, TasteVal, measures research taste. It strips out coding ability and compares only the compute efficiency of research ideas, and finds that frontier models roughly double on this about every three months. Sakana AI set up a dedicated RSI Lab.
The negative side is more concrete. A Google Research paper gives direct evidence of overfitting. In its words, recursive evolution can overfit by memorizing training tasks, showing large in-distribution gains that shrink or vanish out of distribution. Another paper lists the same difficulty first: when you evolve against an eval, it is hard to tell reusable improvements from adaptations to that specific benchmark.
A third paper checks a link RSI depends on, whether agents can build usable evaluations themselves, and finds hand-picked human task samples remain a strong baseline. One analysis models AI progress as a directed graph and concludes that, once calibrated, current feedback loops are not enough for self-sustaining acceleration. The physical AI paper is blunter still. It cannot isolate any gain attributable to recursion itself.
The most vivid result is the Princeton experiment. Opus 4.8 with OpenClaw ran for six days on $3,000 of credits to answer open research questions from two unpublished NeurIPS submissions. Engineering was solid, it did the literature search, and it ran hundreds of experiments. The original authors rejected both, saying the agent was clearly poor at research itself: it locked onto weak approaches early, dismissed hypotheses on tiny samples, and could not back up and restart. One caveat. The experiment used Opus 4.8 and did not test the newer Fable 5.
Jack Clark's two statements look awkward side by side. Reportedly he was bearish on near-term RSI in August because of this experiment. In October, because of the taste benchmark, he moved his expected year for full RSI from 2028 to 2027. These do not conflict. One tests whether an agent can do open-ended research independently. The other tests how efficiently it picks experiments for a given problem.
A few players also cooled things down on purpose. Zhipu says plainly it has not reached RSI. One paper documents unfinished goals and a failed strategy, and separates a reusable component getting better from final task success. One company released a model saying its automated research system produced most of the development work. The press noted this is only a snapshot of that system, and the company offered no outside evidence that its research ability measurably improves with iteration.
9. DeepSeek moved its CUDA stack to Ascend
From late September into October, DeepSeek ported its CUDA-side operator, communication and compiler libraries to Huawei's Ascend, API for API, and open-sourced them. The matrix-multiply library says it is fully API-compatible with the original. The communication library says its public interface matches the NVIDIA version. An operator library added an Ascend backend, following the NVIDIA path, with the runtime picking automatically so the same Python interface runs on both. In October it released the inference framework behind its production service, supporting both.
On the model side, the latest in the window is MIT-licensed open weights at 763B parameters with a 1M context.
Three caveats, or this reads as something it is not.
First, every Ascend performance number is a fraction of Ascend's own hardware peak. There is no NVIDIA comparison table in any first-party material. So matching CUDA is architectural: one interface, a second backend. It is not a head-to-head benchmark.
Second, the communication bandwidth was measured on a PoC firmware provided to DeepSeek with extra manual configuration, and the README says that is not a public release.
Third, two backends does not mean feature parity. The inference framework marks two features as NVIDIA-only.
If this path works, Ascend's software ecosystem does not have to grow from zero. It inherits an interface surface already proven in large-scale production, which is the thing domestic accelerators lacked most. It is also a probe at NVIDIA's moat, because what got copied is not hardware but interface habits.
For now it is only a probe, with no independent benchmark behind it. One more shift is worth noting. Since its August model, DeepSeek no longer publishes SWE-bench Verified numbers. It reports other benchmarks and states the harness used. So the gap between domestic and international models on coding tasks can no longer be compared directly on the new version.
So, are we closer to AGI?
Looking at all nine together, one thread is consistent.
Capability is clearly rising, and it is rising inside a well-bounded region. Anthropic's own line is that writing code is no longer the bottleneck, and the evidence is daily merges going from 2,500 to over 30,000 in four months. OpenAI reports 3.1 agent workdays per eight human hours as of mid-August. Zhipu's inference service was mostly rewritten by its own model and reached production in two weeks. What they share is that the task is already defined, and right or wrong can be checked on the spot. Does it compile, do the tests pass, did throughput go up. Agents do best exactly there.
The bottleneck moved with it, and the new bottlenecks are mostly not on the model side. Source control could not keep up, and two companies each rebuilt it. Human review bandwidth does not scale with the number of agents, which is the core of Osmani's post. None of the three personal agents is fully open, and what holds them back is not capability but how to grant permission.
One sentence from Anthropic deserves to be kept. The latent demand for merged code is effectively unlimited, and every time one bottleneck clears, output rises right back. That explains why more capability does not turn into more results automatically. Demand rises in step, and the human step in the middle gets squeezed harder.
And the step that matters most on the road to AGI is the one with the weakest evidence. The word AGI is asking who defines the problem and who decides it was done right. On that part, over these two months, all I saw was counter-evidence. The RSI block lists several: evals that agents cannot build, poor research taste, gains that cannot be isolated, feedback loops that are too weak. Even the optimistic benchmark with the three-month doubling says in its own text that it does not measure choosing the right problem.
The measuring instruments are flawed too. The 69 self-contradictory tasks above are one example, and repetition cannot catch them. So even if the direction is right, the speed estimate is hard to trust.
Here is where I land. Finishing a task that is already well defined and checkable on the spot is getting cheap fast, cheap enough to change infrastructure. That part of the help is real and deserves no discount. As for defining problems, choosing directions and judging what counts as done, there was no direct positive evidence in these two months.
The distance between those two things may be larger than the score curves suggest. The narrow half is already useful enough to force source control, review process and permission design to be redone. Those are likely the places that change most in the next year or two. or two.
Sources
Source control
- Redesigning source control at Anthropic, 2026-10-13
- Building Git infrastructure for agent-scale development, 2026-10-06
Code review
- Human judgment doesn't leave the software factory. It relocates., Addy Osmani, 2026-08-21
- Maybe We Shouldn't Be Reviewing All This Code, Rachel Laycock, 2026-09-02
- ReviewBench, 2026-10-05
Benchmark trust
- SWE-Bench Pro Verified, 2026-09-08; public leaderboard V2, 2026-09-22
- Trace Evolution Bench, 2026-10-10
- RealCLI, 2026-10-15
- Cortex report summary, published 2025-11-12, data window 2024Q3 to 2025Q4
Decision models
- Decisions API, 2026-10-22
- Jev, Simon Willison, 2026-09-21
- LLM2Jev
Harness and plugins
- Introducing the Agents API, 2026-09-10
- Claude Code glossary
- Claude Code mods
- Donating Agent Skills to the Agentic AI Foundation, 2026-10-22
- Decoding the new AI lingo, 2026-09-02
- Are Harnesses Worth the Cost?, Naresh Jain, 2026-10-13
- Alibaba Cloud framework via IT168, 2026-09-22; official post not retrieved
Interfaces
- When chat is the wrong UI, Burke Holland, 2026-09-24
- The next developer interface is ambient intelligence, Martin Woodward, 2026-10-15
Personal agents
- Introducing Muse, Meta, 2026-09-08
- Introducing dots, OpenAI, 2026-09-29
- Claude Duet, Anthropic, 2026-10-21
RSI
- Automated researchers can reliably mitigate alignment failures, 2026-08-28; paper
- Research acceleration: the view inside OpenAI, 2026-09-06
- How GLM built its inference infrastructure, Z.ai, 2026-09-17
- TasteVal, 2026-10-05
- RRSI, Google Research, 2026-09-21
- ModularRSI, 2026-09-14
- EvalResearchBench, 2026-10-03
- The Economics of Recursive Self-Improvement, 2026-09-14
- Toward Recursive Self-Improvement in Physical AI, 2026-10-21
- Princeton shadow-review experiment coverage, MIT Technology Review, 2026-08-18
- Sakana AI RSI Lab
DeepSeek and the domestic stack
- DeepGEMM-Ascend, 2026-09-30
- DeepEP-Ascend, 2026-09-30
- TileKernels, Ascend backend 2026-09-30
- DeepInfer, 2026-10-16
- DeepSeek-V4.1-Flash-1017 model card, 2026-10-17
