--- title: "Everyone is Building the Same Thing: All Agents Will Be Coding Agents" url: "https://www.morphllm.com/blog/all-agents-coding-agents" description: "Lovable and Cursor are obvious coding agents. What's less obvious: Linear, Posthog, customer support agents, marketing agents, and hardware telemetry platforms are all becoming coding agents too. Code is the substrate that lets you build the feature that builds all features." date: "2026-03-18" author: "Tejas Bhakta" --- # Everyone is Building the Same Thing: All Agents Will Be Coding Agents "We're not a coding agent." I hear that sentence about twice a month on intro calls, and I've learned to just write down the date, because what follows is pretty close to clockwork. A hardware telemetry company said it to us in the spring. They were polite about it, and they weren't wrong about their product as it stood: an agent that answered device questions from a knowledge base, well liked, no code anywhere near it. Then one of their customers wanted overheating devices broken out by region and firmware and plotted against last Tuesday's ambient temperature, and there went the roadmap. No tool existed for that question because nobody had heard the question before. The thing that answers questions nobody has heard before is code, so this company runs Python in a sandbox now, and their website still says they're not a coding agent, which I find sort of charming. I keep watching this same movie with different logos. Chat-with-docs ships first and buys a quiet month. API integrations land next, a tool per action with some function-calling glue, a CRM lookup here, an order-status check there. Then somebody's customer asks the roadmap-breaking question and the sandbox line item shows up in the next planning cycle. Meanwhile the obvious coding agents, the ones that were never in denial about it, have turned into a market nobody needs convincing on: Cursor [topped $4B annualized](https://app.dealroom.co/news/note/cursor-tops-4b-annualized-revenue-june-2026) in June (it was $2B in February), Lovable [crossed $500M](https://techcrunch.com/2026/06/09/lovable-says-it-has-hit-500m-in-annualized-revenue-with-1-million-new-projects-a-week/), and Anthropic's run-rate [hit $47B](https://simonwillison.net/2026/May/29/anthropic/) in May with Claude Code on its own an $8B business. My claim is that the telemetry company and Cursor are in the same business now. One of them just hasn't updated the website. ## Why this keeps happening Every agent platform I've watched walks the same path. ``` Stage 1: Chat with docs "Answer questions from our knowledge base" Tools needed: RAG, embeddings Stage 2: Predefined actions "Check order status, issue refund, update CRM" Tools needed: 5-15 API integrations Stage 3: Composed workflows "If the customer is on plan X and their usage exceeded Y, offer Z discount and log it" Tools needed: 20-50 integrations + conditional logic Stage 4: Unbounded requests "Which customers in EMEA churned after our pricing change, cross-referenced with NPS scores, excluding trial accounts?" Tools needed: ??? ↓ Code. ``` Stage 4 is where predefined tools give out. You can't guess every query in advance, and you can't ship a tool for every combination someone might want. [Davis Treybig](https://davistreybig.substack.com/p/all-agents-will-become-coding-agents) put it well: "It is near impossible to fully enumerate all the tools or capabilities a given agent should have in any domain." Code doesn't have that ceiling. It can plot the data, catch the anomaly, hit an API nobody planned for, draw a chart nobody designed. The only thing holding it back is how good the models are at writing it, and the models are good enough now. ## The evidence is everywhere None of this is hypothetical. Work down any category of software and the conversion has either happened or is visibly in progress. **Spreadsheets became coding agents.** Excel Copilot [generates and executes Python](https://techcommunity.microsoft.com/blog/excelblog/introducing-copilot-support-for-python-in-excel-advanced-data-analysis-using-nat/3928120) straight from natural language, pandas and matplotlib and scikit-learn included. Somebody asked it to forecast Q3 and formulas weren't going to cut it. **Search engines became coding agents.** Perplexity shipped [E2B code execution](https://e2b.dev/blog/how-perplexity-implemented-advanced-data-analysis-for-pro-users-in-1-week) in a single week, and now runs millions of sandboxes a month. Labs mode turns a search query into an interactive dashboard, and "show me this data" turns out to need code. **Data warehouses became coding agents.** Snowflake launched [Cortex Code](https://www.snowflake.com/en/news/press-releases/snowflake-unveils-cortex-code-an-ai-coding-agent-that-drastically-increases-productivity-by-understanding-your-enterprise-data-context/) in February 2026, and on internal data science tasks it beats leading coding agents 77.1% to 32.1%. What they shipped there was a coding agent, not the nicer query builder you might have expected from a data-warehouse company. **Analytics platforms became coding agents.** PostHog's AI [writes HogQL from natural language](https://posthog.com/blog/8-learnings-from-1-year-of-agents-posthog-ai), runs it in a sandbox, and renders the result. It took them three architecture rewrites to get there. The agent now handles insights, dashboards, feature flags, surveys, session replays, and A/B experiments, and [34% of AI-created dashboards](https://newsletter.posthog.com/p/what-we-wish-we-knew-before-building) come through their MCP server. When someone types "show me retention by cohort," there's no template behind it. The agent writes the SQL, runs it, and draws the chart. **Database app builders became coding agents.** [QueryPlane](https://queryplane.com) takes a plain-English description of an internal tool and produces a working data app. An agent reads the schema, writes the SQL, validates the config, assembles the UI. The drag-and-drop form builder became code that a Claude Agent SDK agent writes on demand, with schema changes gated behind a human's explicit approval. **Design tools became coding agents.** Figma teamed up with [Anthropic](https://www.cnbc.com/2026/02/17/figma-anthropic-ai-code-designs.html) and [OpenAI](https://openai.com/index/introducing-codex/) to move between code and design, and Figma Make generates production front-end code. "Make this responsive" is, underneath, a code problem. **Project management became coding agents.** Linear's CEO went ahead and declared ["issue tracking is dead"](https://linear.app/next). Coding agents are now installed in [75% of enterprise workspaces](https://linear.app/changelog/2026-03-24-introducing-linear-agent), a quarter of new issues get authored by agents, and from any issue you can [launch Claude Code, Cursor, or Codex](https://linear.app/changelog/2026-02-26-deeplink-to-ai-coding-tools) with the full context already filled in. With Code Intelligence and a native coding agent on the roadmap, the tracker is quietly becoming a place you dispatch coding agents from. **Knowledge management is next.** Notion already ships an [MCP server with 22 tools](https://developers.notion.com/docs/mcp) plus a [Claude Code plugin](https://github.com/makenotion/claude-code-notion-plugin) so agents can read and write Notion data, and their [Custom Agents](https://www.notion.com/blog/introducing-custom-agents) run multi-step workflows off schedules and triggers. All of that stays inside Notion's own action set, though. Ask it to cross-reference your product specs against GitHub issues and spit out a migration plan and you're right back at the wall. There's no getting past it without code. Notion hasn't announced code execution, but I'd bet on where the line is pointing. **CRMs became coding agents.** Salesforce's [Agentforce Vibes](https://developer.salesforce.com/docs/platform/einstein-for-devs/guide/einstein-overview.html) generates Apex from natural language for its 12,000-plus customers. When somebody asks it for a trigger on Opportunity stage changes, there's no canned workflow behind that request. It's the model writing Apex live. **Customer support became coding agents.** Intercom Fin now runs [code execution right inside a conversation step](https://www.intercom.com/blog/whats-new-with-fin-3/). And Klarna's AI got through [2.3 million conversations in one month](https://openai.com/index/klarna/), roughly what 700 human agents would handle, pushing refunds and account changes out through API calls as it went. **Industrial automation became coding agents.** Siemens Industrial Copilot [generates PLC code](https://press.siemens.com/global/en/pressrelease/bringing-generative-ai-industry-siemens-industrial-copilot-wins-hermes-award-2025) from natural language right inside TIA Portal. It won the Hermes Award at Hannover Messe 2025, and Thyssenkrupp is rolling it out worldwide. Not one of these companies set out to build a coding agent. They all ended up in the same place because they all hit the same wall. ## The wall Combinatorial complexity is the wall, and every one of these companies met it the same way. Give your agent 15 predefined tools and users can string them together a handful of useful ways, which stays manageable. Push it to 50 and the number of possible combinations blows up, though most of them are nonsense, so a bit of fencing still keeps things under control. The trouble starts when a user wants a capability that lives outside the tool set entirely. "Cross-reference our telemetry with this CSV I just uploaded." "Build me a calculator that models our pricing under three different discount structures." No amount of recombining your 50 tools produces either one. ``` Predefined tools: ┌──────────────────────────────────┐ │ Tool A Tool B Tool C │ │ Tool D Tool E Tool F │ │ ... │ │ Useful combinations: ~50 │ │ User requests covered: ~80% │ │ │ │ The other 20%? │ │ ┌────────────────────────────┐ │ │ │ Requires code generation │ │ │ │ (and it's the 20% that │ │ │ │ determines whether they │ │ │ │ renew) │ │ │ └────────────────────────────┘ │ └──────────────────────────────────┘ ``` That last 20% carries the renewal. A customer who got the 80% says "neat" in the QBR. A customer who got the missing 20% tells you they can't go back to doing it by hand. ## Code wins over a bigger tool pile You might reasonably ask why the answer is code rather than a bigger pile of tools. There are three reasons, and they stack. The first is token economics. Cloudflare has 2,500 API endpoints, and if you exposed every one as an MCP tool the descriptions alone would eat over a million tokens before the agent did anything. Their answer was [Code Mode](https://blog.cloudflare.com/code-mode/): turn the API into a TypeScript SDK and let the model write code against it. On complex batch operations that cut token usage by [81%](https://blog.cloudflare.com/code-mode-mcp/). Somewhere past a certain count, piling on more tools starts hurting the agent while code keeps helping it. The second is accuracy. A [GeoJSON study](https://www.tandfonline.com/doi/full/10.1080/20964471.2026.2615511) put code generation and function calling head to head and got 97.14% accuracy for code against 85.71% for function calling. The gap gets wider on hard tasks, because code can express conditionals and loops and data transformations that a chain of tool calls just can't. The third is that code, once written, keeps running. [XY.AI Labs](https://www.xy.ai/tech-behind-xyai/the-code-factory-manifesto) framed it nicely: "The LLM generates code once, then that code executes forever with zero inference cost." A tool-based agent pays for an LLM call on every invocation. A code-generating agent pays once and the code runs on its own after that. One's an interpreter, the other's a compiler. ## The infrastructure is already here The plumbing already exists, which is the part that makes this feel inevitable rather than speculative. E2B went from 40,000 to [15 million sandboxes a month](https://e2b.dev/blog/series-a) in a year, with 88% of the Fortune 100 signed up. Daytona hit [$1M forward revenue in under three months](https://www.prnewswire.com/news-releases/daytona-raises-24m-series-a-to-give-every-agent-a-computer-302680740.html). Modal Labs is running at [$300M ARR](https://modal.com/blog/modal-series-c), five times its September number, and closed a $355M Series C at $4.65B in May. None of these are developer-tools companies anymore. They're agent infrastructure companies, and their customers are the marketing agents and support platforms and analytics tools that need to run code. Roughly half of the recent [YC batches](https://pitchbook.com/news/articles/y-combinator-is-going-all-in-on-ai-agents-making-up-nearly-50-of-latest-batch) are AI agent companies, across insurance and logistics and video production. The agent is how they ship value, and shipping value comes down to executing code. ## What this means for the stack If every agent turns into a coding agent, three things start to matter a lot. Speed matters first. A marketing agent writing a Python script to crunch campaign numbers has to come back with an answer before the user tabs away. Our customers see a tight 1:1 relationship between inference speed and conversion. The flow window sits around 5 seconds; stay under it and users stay engaged, go over it and each extra second bumps abandonment by roughly 10%. That's why we built Fast Apply to run at 10,500 tok/s. Not because developers asked for it, but because every agent is a coding agent now and speed is the thing that binds. Search matters next. Coding agents spend [60% of their time searching](https://cognition.ai/blog/swe-grep) rather than coding, and it doesn't matter whether the "code" is a React component or a Python script chewing on telemetry: the agent still needs the right files, the right context, and a working memory that isn't full of junk. [Anthropic measured](https://www.anthropic.com/engineering/claude-code-best-practices) a 90% improvement going from single-agent to multi-agent search. We built [WarpGrep](/products/warpgrep) for exactly that, an RL-trained search subagent in its own context window that keeps the main agent's memory clean. Context management matters last and maybe most. Agent sessions now run past 24 hours. [Augment Code](https://www.augmentcode.com/) watched accuracy fall from 89% at 8K tokens to 25% at 1M. The context is all there; the model just can't use it. [Flash Compact](/products/compact) drops 50 to 70% of the context at north of 33,000 tok/s while keeping every surviving line verbatim, which is compaction rather than summarization. Every agent inherits the context-rot problem that coding agents have been fighting for two years now. ## The transient period We're in a strange window right now where none of this is obvious yet. Companies still pitch "AI agents for marketing" and "AI agents for support" and "AI agents for analytics" like they're three different products. They aren't. They're the same coding agent wearing three different system prompts. The convergence shows up in the numbers. [92% of US developers](https://www.netcorpsoftwaredevelopment.com/blog/ai-generated-code-statistics) use AI coding tools every day, and [46% of all code](https://www.netcorpsoftwaredevelopment.com/blog/ai-generated-code-statistics) written by active developers now comes from AI. But the stat that actually moves me isn't about developers at all: [Anthropic reports](https://resources.anthropic.com/2026-agentic-coding-trends-report) that Claude Cowork, their coding tool aimed at non-developers, is one of their fastest-growing products. People who don't code are writing code, because the agent is writing it for them. Claude Artifacts crossed [500 million creations](https://deepnewz.com/software/anthropic-turns-claude-into-no-code-app-platform-500-million-artifacts-1d4baf1c). Most of them are code. Most of the people making them aren't developers. The category walls are coming down. The companies that spot this early and build on coding infrastructure are going to leave behind the ones that keep bolting on more tools. Code is the substrate that lets you build the feature that builds all the features. Every agent is about to work that out for itself.