This week in AI: Cursor 2.0 and the agent stack

Anysphere launched Cursor 2.0 this week, and the headline feature is Composer, a coding model the company trained in-house rather than renting from OpenAI or Anthropic. The pitch is latency: Composer is built for agentic work, where a model fires off dozens of tool calls in sequence and every 500 milliseconds of thinking time compounds. Cursor's own benchmarks put it at roughly twice the speed of comparable general-purpose models on coding tasks, with meaningfully fewer tokens burned per completion.

The other big shift is the multi-agent interface. You can now spin up several agents at once, each working in its own git worktree, then review the results side by side before merging anything. If you've ever asked one agent to refactor something and waited ten minutes to find out it chose the wrong approach entirely, this fixes that. You let two or four agents take different swings and pick the diff you like. It's the same pattern we use with human contractors: parallel bids, one decision.

The company also dropped its growth numbers alongside the release: over 4 million registered users and around $500M in annual recurring revenue. Those are numbers that let you train your own models, and the IDE-in-beta move confirms the strategy. Cursor is coming for VS Code's core market, not just the AI plugin slot on top of it.

My take as someone who pays for a few of these tools: the vertical integration bet is the interesting part. A wrapper dies the moment the underlying model provider ships a competing feature. A company that owns the editor, the agent runtime, and now the model has a real moat, because the model is tuned for exactly one job and the product is shaped around it. The tradeoff is obvious too. Composer is built for Cursor's loop, and if you switch editors, that advantage stays behind. Lock-in is back on the menu, except this time you're locking into a model tuned for how you code.

Cloudflare had a rough week. A permission revocation inside a bot-fighting database rippled through the company's global network and knocked out a chunk of the internet, including ChatGPT, X, Discord, and Canva, for a stretch of hours. The trigger wasn't an attack or a capacity problem. It was an automated security system that, after the permission change, started blocking legitimate traffic across the network.

CEO Matthew Prince published a detailed postmortem the same day, walking through the failure chain and what changes as a result. The transparency got credit from the developer community, and it should. Most companies hit with an outage at this scale issue a two-sentence status update and hope the news cycle moves on. Prince published the mechanism of failure. That said, transparency doesn't reroute your traffic during the next one, and it doesn't recover the conversions, API calls, or trust you lose while the error pages are up.

The timing made it worse. The disruption landed about a week after Anthropic announced it was moving its API fleet onto Cloudflare Workers, which means one of the biggest AI companies had just consolidated onto the exact infrastructure that went down. That's not a knock on the decision, edge networks are the right call for latency-sensitive AI traffic, but the sequencing was uncomfortable. Consolidation is efficient until it isn't, and the moment it stops being efficient is rarely the moment you chose.

The reaction on Hacker News cut to the real issue for anyone running production systems:

For indie builders the lesson is cheaper than a multi-cloud migration: know which external APIs your product dies without, and have a degraded mode ready. Concretely, that means serving cached or stale data behind a banner instead of a hard error, queuing writes for retry instead of dropping them, and making sure the read path of your app survives even when a third-party call times out. If your app depends on one inference provider, one auth vendor, and one edge network, the consolidated stack most small products now run on, a single bad deploy somewhere in that chain is your outage, even though you did nothing wrong. Map the dependency chain before it maps you, and decide in advance which failures you can ride out and which ones require a fallback you've actually tested.

Anthropic released the Agent Skills specification, and it might end up being more consequential than most of the model releases this quarter. The format is deliberately boring: a folder containing markdown instructions, scripts, and resources that a model loads on demand when a task calls for them. Anthropic's engineering post walks through the design, and the key idea is progressive disclosure. Instead of stuffing every convention, script, and style guide into a system prompt and praying it fits in context, the agent loads the relevant skill only when the task needs it.

If you've built anything with a long system prompt, you know the failure mode. The prompt bloats, the model starts ignoring the middle of it, and your token costs climb for instructions the model needed once. Skills split that knowledge into discrete, loadable packages. Your brand voice skill loads when the agent writes copy. Your SQL conventions skill loads when it touches the warehouse. The rest of the time, they cost nothing.

Two design decisions make this spread beyond Claude. First, it's markdown and directories, so any developer can write a skill in an afternoon without learning a new framework. Second, it's tool-agnostic. Claude Code uses it natively, but nothing in the spec ties it to Anthropic's stack, and community registries where developers share skills for document generation and data analysis are already appearing.

OpenAI's AgentKit push suggests a convergence is coming: both labs are racing to define how agents carry organizational knowledge, and the winner of that race gets to set the interface everyone builds against. Anthropic releasing the spec openly is a bet that distribution beats control. In my experience running a bootstrapped SaaS, open formats win these fights more often than people expect, because nobody wants to rebuild their convention libraries per vendor. My practical advice: write your team's conventions as skills now, in markdown, in a folder structure you control. Whether the standard ends up being Anthropic's or a merged one, the exercise of packaging your institutional knowledge for an agent is the same work.

Sentry shipped its Agent Kit one week ahead of OpenAI's DevDay, and the timing tells you the company knows exactly what race it's entering. The kit bundles three things: a monitoring SDK that works regardless of which agent framework you use, a hosted eval loop, and new visualizations that render an agent's trajectory through a task. The pitch is that agents fail differently from traditional software, and the monitoring tools we built for crashes and exceptions don't cover it.

That framing is correct, and anyone who has put an agent in production knows it. A traditional bug is deterministic: this input, this stack trace, this fix. An agent failure is often non-deterministic. The same prompt works nine times and then, on the tenth, the model decides to call a tool with the wrong arguments, or loops, or confidently returns garbage. There's no stack trace for a bad decision. You need to see the full trajectory, every tool call and every intermediate thought, to figure out where the loop went sideways.

The eval loop is the part I find most interesting as a founder. It gives you a sandbox where you can change a prompt or swap a tool and then measure the effect across a benchmark suite before the change touches production. If you've ever shipped a prompt tweak on a Friday and spent the weekend finding out it broke your refund workflow, that's the pain this addresses. Sentry also supports over-the-air config updates, so you can correct an agent's behavior in production without a redeploy.

The competitive angle matters too. Sentry is fighting DataDog and a cluster of AI-native startups to become the default observability layer for agents, and it moved first with a code-agnostic offering. For indie founders the calculus is simple: if you're shipping agentic features this year, you'll need trajectory logging and evals eventually. Building that yourself is a month of work nobody thanks you for. Whatever vendor you pick, make sure your agent emits structured traces from day one, because you can't retrofit observability onto logs you never wrote.

OpenAI used DevDay to launch AgentKit, its end-to-end framework for building and deploying agents. The package includes Agent Builder, a visual canvas for wiring together agent workflows, connectors to enterprise data sources, a built-in evals system, and versioned deployments for taking an agent from draft to production. If you've seen tools like n8n or Langflow, the visual builder will feel familiar, except it's native to the OpenAI stack and wired directly into their models.

The company's framing at the event was that 2025 was the year of experimentation and 2026 is the year of deployment. That's marketing language, but there's a real shift behind it. Enterprises ran pilots for two years and are now under pressure to put agents into production with audit trails, versioning, and evals. OpenAI is building for the buyer who wants one vendor to cover the whole path instead of stitching together five libraries and a prayer.

There's a catch for early adopters, and it's the part I'd pay attention to if you built on OpenAI's earlier agent tooling. Some of those older products get wound down through late 2026, which means migration work for anyone who bet on the previous generation of the platform. This is the recurring pattern with platform vendors: the toolkit that wins today's announcement is not the toolkit you migrated to last year. If you build on AgentKit, read the deprecation timeline before you commit architecture to it.

The visual builder angle is worth a take from the indie side. Lowering the barrier for non-technical stakeholders is a enterprise sales motion, but it also means your customers can increasingly assemble simple agents themselves. If your SaaS is a thin layer of prompt wiring with a UI on top, AgentKit plus connectors is a substitute showing up on your buyers' procurement lists. The defense is the same as it's always been: own the workflow, the data, or the integration depth that a visual canvas can't replicate. Generic agent assembly is becoming a platform feature, and platform features are a bad business to compete with when you're a team of one.

Away from the platform wars, the interesting indie story this week is the march of small, cheap models. Pieter Levels, the most visible solo founder in the space, reported shipping a tiny model, around 4 million parameters by his account, that runs on consumer-grade hardware for roughly $19 a month in hosting costs. Treat the specific numbers as his claims to verify, but the direction is the story: specialized tasks are getting served by models that cost a rounding error compared to frontier API calls.

This matters because of the economics underneath indie SaaS. Analysis of the broader ecosystem suggests a brutal distribution: roughly 54% of indie products make zero revenue, and most micro-SaaS projects that do earn money stay under $1,000 MRR. When your total revenue is four figures a month, a $300 monthly inference bill for one AI feature is not a growth investment, it's a funeral expense. Small open-weight models change that math. A fine-tuned 4M-parameter model handling one narrow task, classification, extraction, routing, runs at near-zero marginal cost on a cheap GPU box.

The pattern I keep seeing work: founders pick a boring, specific niche, then use a small model for the one repetitive task inside it. The indie hacker case studies coming out this month back this up. The teams hitting real MRR, like the $23k MRR SaaS that launched last summer, aren't running frontier models on general chat problems. They're narrow, priced at $39/mo, and their AI features are task-specific. The boring-niches playbook keeps winning because low overhead is a survival trait, and small models are overhead reduction in its purest form.

My honest take: the frontier labs will keep owning anything requiring reasoning across domains, and that's fine. The indie opportunity isn't competing with GPT-class models. It's finding the tasks where a 4M-parameter model gets 95% accuracy at 1% of the cost, and building the workflow and data moat around it. Margins are the whole game when you're a team of one, and cheap inference is the biggest margin lever to appear since usage-based pricing.