Rotem Alaluf

As agents become the biggest users of software, then all software has to be available in a headless fashion. Agents won’t be using your UI, they’ll be talking to your APIs. So the question becomes what is the business model of software and this headless approach in the future? Here are a few thoughts on how everything plays out based on what we’re seeing and doing at Box, but also conversation with other platforms. 1) Seats don’t go away for *people*. Seats are still a convenient and efficient way to have a customer use technology predictably for a set of users within a baseline set of usage. The key, though, is that when the customer pays for a seat, it has to come with a set of usage of APIs on behalf of that user that the agent can use on their behalf. The user will need to be able to interact with their data and the underlying tool via any agent they work with, and an embedded amount of usage will come with the seat. I would imagine most software -Box included- will enable seats to work with their data at a relatively high volume via systems like ChatGPT, Codex, Claude, Gemini, Cursor, Copilot, Perplexity, Factory, Cogniton, et al. quite seamlessly. If you don’t do this, you’re DOA. 2) Agents may have “seats” if they are doing stateful work in the system, but they will be priced very differently than people. Seats (or the equivalent) can make sense when you have an agent that has its own workspace, stores its own data, needs a different set of permissions compared to the user, and so on. If a company wants this agent to be around for long period of time, that may very well look like another “user” in the system. Openclaw-style agents highlight what this future could look like. The only issue on pricing here is that one customer could decide to do all their work in 1 agent, and another might split it into 1,000 agents. So pricing like a human seat is nearly impossible and impractical; each company will have a different approach for this as it gets tricky perfectly trying to capture all the value within an agent seat. 3) The dominant pricing for headless use that goes above the seat allotment, or when an agent is firmly acting on their own, will be a consumption model. Many enterprises software platforms have previously operated like this with PaaS options, and agents will look like another machine user of their system. In some cases the APIs might get priced just as they did previously, but in other cases there may need to be new types of APIs that represent the work an agent would do in one go -more akin to an outcome- instead of a series of API calls. This is especially germane when the headless software also has an agentic use-case embedded within in, such as orchestrating the process within their own system via AI. Overall the growth of this usage pattern is effectively unbounded as the use-cases for agents operating on data in these systems will dramatically exceed what people do with their data and tools today. Every platform that goes headless (which will be anyone that wants to take advantage of agents) will need to adopt a model like this. Some may fight it initially but it’s an inevitably as there will always be more and more agents outside your platform than people. Overall, there’s a lot of really interesting changes left to come in software due to headless use of these systems. Early days.

this is … odd. the whole problem with agentic code is that people wind up with hard to debug redundancies, security holes, deleted databases, etc., which is exactly why you need roadmaps and code reviews, with AI-written code. I am with @Grady_Booch on this one (and almost everything else). I don’t doubt that we will have more code written cheaper than ever, but a lot of it is going to be a mess unless there is serious oversight. (Companies like Amazon have already seen this.)

Are we ready to give AI agents the keys to the cloud? Cloudflare thinks so spr.ly/6010BBRA7G

New role: Agentmeister.

Five US firms control 70% of global AI compute. The UK's 'middle powers' chip alliance is the right instinct, twelve months too late, and three billion pounds short. Sovereign AI without sovereign compute is just a press release.

Really good article here about the future of UI in the era of AI: • We are going in two directions right now: headless APIs/CLIs for agents, and generative UIs for humans • Agents don't click buttons; they call APIs. Applications can't simply force a UI on users and expect them to adapt. • Most teams are still shipping text-only chat boxes and calling it AI. • The interface used to ship with the app. Now it ships with the agent, composed at runtime, appearing at the moment of intent, vanishing when done. • Teams that build the vocabulary their agent speaks will win; teams that settle for long-form text responses with a nice design won't.

@MarcusSpillane "Already dead, just don't know it yet" is the right frame. Zombie software. Still billing. Still renewing. Clock running.

@AlalufRotem Seeing this firsthand. Half the enterprise vendors we integrate with built beautiful UIs that are completely useless to an agent. The ones rebuilding API-first will survive. The ones bolting "AI features" onto human workflows are already dead, they just don't know it yet.

Enterprise software is being rebuilt so agents can operate it directly - not through a human UI. The software stack is not being “augmented” for AI. It is being redesigned around agents as primary users.

I've had my company in the UAE for almost two years. I'm so happy I procrastinated on doing my first set of accounts (still within the deadline though). Now an AI agent can just do it for me.

The factory owner parallel people ignore: the owners who failed weren't stupid. They were rational. They saw imperfect machines, real costs, legitimate risk. Their reasoning was sound. Their conclusion was fatal. The gap between sound reasoning and right outcome is called timing.

That changes everything: product design, workflows, governance, permissions, auditability, and how work gets done.

Fireside chat at Sequoia Ascent 2026 from a ~week ago. Some highlights: The first theme I tried to push on is that LLMs are about a lot more than just speeding up what existed before (e.g. coding). Three examples of new horizons: 1. menugen: an app that can be fully engulfed by LLMs, with no classical code needed: input an image, output an image and an LLM can natively do the thing. 2. install .md skills instead of install .sh scripts. Why create a complex Software 1.0 bash script for e.g. installing a piece of software if you can write the installation out in words and say "just show this to your LLM". The LLM is an advanced interpreter of English and can intelligently target installation to your setup, debug everything inline, etc. 3. LLM knowledge bases as an example of something that was *impossible* with classical code because it's computation over unstructured data (knowledge) from arbitrary sources and in arbitrary formats, including simply text articles etc. I pushed on these because in every new paradigm change, the obvious things are always in the realm of speeding up or somehow improving what existed, but here we have examples of functionality that either suddenly perhaps shouldn't even exist (1,2), or was fundamentally not possible before (3). The second (ongoing) theme is trying to explain the pattern of jaggedness in LLMs. How it can be true that a single artifact will simultaneously 1) coherently refactor a 100,000-line code base *and* 2) tell you to walk to the car wash to wash your car. I previously wrote about the source of this as having to do with verifiability of a domain, here I expand on this as having to also do with economics because revenue/TAM dictates what the frontier labs choose to package into training data distributions during RL. You're either in the data distribution (on the rails of the RL circuits) and flying or you're off-roading in the jungle with a machete, in relative terms. Still not 100% satisfied with this, but it's an ongoing struggle to build an accurate model of LLM capabilities if you wish to practically take advantage of their power while avoiding their pitfalls, which brings me to... Last theme is the agent-native economy. The decomposition of products and services into sensors, actuators and logic (split up across all of 1.0/2.0/3.0 computing paradigms), how we can make information maximally legible to LLMs, some words on the quickly emerging agentic engineering and its skill set, related hiring practices, etc., possibly even hints/dreams of fully neural computing handling the vast majority of computation with some help from (classical) CPU coprocessors.

Increasingly, I think, we will see a gap between what you can do with frontier model APIs & what you can do with the native apps from the frontier labs (Codex, Claude Code). Models developed and trained with their native harnesses in mind have more capabilities in their harnesses

This report from @CenDemTech's AI Governance Lab has been a long time coming and I'm so glad it's out: original research from @mbogen, @aawinecoff and more on the unpredictable safety drift that occurs in foundation models when you do even a little bit of fine-tuning.

Build governance infrastructure that can handle a moving line. Not one optimized for today's boundary.

Hybrid workforce models built on that assumption need a second look. The line between 'human work' and 'agent work' is moving faster than most transformation roadmaps account for.

AI agent research is beginning to outperform human researchers.

The compounding advantage works both ways. Agents maintained well compound upward. Agents left ungoverned compound toward failure. Pick one.

This is agentic drift. Not a failure of technology. A failure of architecture. The agents performed exactly as configured. For the wrong moment.

Wrong question: how many agents should we deploy?