The Future of Agents

•
aisoftware

Recently I've been thinking a lot about what the future of human <> agent interaction will look like. Here are a few predictions of what the world will look like in 2 years:

Personal Agents

The era of app developers building AI chat into apps and websites is ending as fast as it started. Power users are investing in their own personal agents with Hermes Agent, OpenClaw, and Claude Code. Services are becoming AI-native with MCP servers, CLIs, and skills. Users are switching to tools that have AI integrations and abandoning ones that don't. Even websites are becoming agent-accessible with WebMCP and content-type: text/markdown headers. The infrastructure for personal agents is being laid fast - we've hit a point of no return.

Visual interfaces like websites and desktop apps will remain, but they will be reserved for use cases where complex visual interaction makes sense over chat. Visual apps like Notion and Linear will still be popular, but we won't be chatting inside them - we'll be managing them with our agent in a separate window side-by-side. Users will want to have a single agent that they know and trust, fully connected to their tools with memory and context. Why use chat inside of an app when my agent is more powerful and already knows everything about me?

This also makes sense from the perspective of app developers who need apps to be AI-native, but have no way to cover the enormous variable cost of users' token usage. Charging usage-based fees is an option, but would not make sense for consumer software. Instead, we'll see things move towards a Bring Your Own Agent model. Tokens are the new monthly utility bill alongside gas and electricity.

Market forces point to a world where Siri and Copilot dominate the consumer agent market simply by being built into the OS. Distribution and convenience are key here - there's a reason that Apple bundles Safari and Apple Mail with iOS and Mac. We'll see the same pattern for agents.

Agents Will Be Cloud-Based

Today, you see a subset of the population experimenting with CLI-based agents on their personal machines, buying Mac Minis, and building personal home labs on Kubernetes clusters. It's like the early days of the internet before managed services like iCloud and Google Workspace became the norm.

Soon though, the cloud will be the natural home for agents. Cloud allows agents to be long-lived background processes that run dependably while you sleep. Running agents on-device can't compete on reliability or convenience, and convenience is king.

On-device agents will still be a thing when fast disk IO, privacy, or cost are the main concern - but those will be niches, not norms. We will once again sleep with our laptop lids fully closed.

Software Will Be (Even More) Malleable

Software malleability and its cousin, portability, have always increased over time, and AI is a new inflection point. Over time, general-purpose tools tend to eat niche tools - but new categories also open up. Notion can now be your calendar, project management tool, and note taking app, all in one. Meanwhile you probably have Claude installed today and you didn't have it two years ago. AI accelerates this all-in-one trend to the extreme, as it replaces so many tools that were primarily about manually inputting and outputting data. Skills - or even just the ability to chat itself - are replacing entire categories of apps.

I do find generative UI compelling here - and I can't imagine it not being a thing in the future - but so far I've been a bit underwhelmed with what I've seen. Personally, I feel like the concept of gen UI will make sense for simple things, but it won't replace something like Notion which probably has millions of human hours of UX research behind it. MCP Apps in ChatGPT are also interesting here, though not particularly malleable.

App Development Will Change

Indie app developers are in the most difficult spot they've ever been in. Traditional niche apps are getting replaced categorically by AI. Why install a personal finance app when I can connect my bank to Claude and add a budgeting skill instead? As an indie developer, you have to decide if you're going to implement AI features. If you do, how do you pay for token usage? Do you eat the cost as part of the monthly subscription fees? Do you tack on usage-based pricing? Increase your prices? There are two options here:

Bring Your Own Key (BYOK): Users can put their own API keys in and pay for usage from their own budget. This works, but non-technical users aren't familiar with API keys - and technical users can potentially see the prompts that get sent to the inference, so the agent's architecture wouldn't be particularly proprietary. On top of that, the user has to trust that the app is going to be honest and respectful while using their API key. Adding a "Connect OpenRouter" button that shares API Keys via an OAuth flow and adding token limits can help with some of the convenience issues here, but the built-in agent would still be lacking other things like search, memory, and an execution environment.

Bring Your Own Key flow: the user hands their API key to the app, which crosses a trust boundary — the app sees your key and data, and its built-in agent only knows what the app passes it, with no shared search, memory, or execution between apps.
BYOK: your key and data cross into the app's trust boundary, and nothing carries over between apps.

Bring Your Own Agent (BYOA): This ties directly back into the personal agents prediction, and I think this is the best approach. Apps will expose functionality via MCP, CLI, or WebMCP and bring well-designed UI as a niche value proposition. The user doesn't need to trust the app (as much) and the agent retains all memory and its natural execution environment. If my prediction is correct, I don't think the term BYOA will still be a thing in 5 years - it will just be how things work.

Bring Your Own Agent flow: your key and data stay with your personal agent, which holds memory, context, and an execution environment; the app only exposes functions over MCP, CLI, or WebMCP, and your agent carries everything across every app.
BYOA: your key, memory, and execution stay with your agent — the app only exposes functions.

The Era Of Agent Clients

Right now, purpose-built desktop and web apps like Claude Desktop are the norm for managing AI agents. I think there are two possible futures here - possibly even co-existing:

Chat apps like Telegram and Slack are the de-facto way of interacting with personal agents like OpenClaw. They're powerful because they allow multiple people to chat with multiple agents in the same room from their phones, and now they're building in AI features - reimagining them as communication tools not just for humans, but for agents.

I could see a world where general-purpose chat apps that add agent features like streaming, tool-call state, and skills could eat purpose-built AI apps like Claude Desktop. The big question here is whether the tools for managing agents end up following the UX patterns of human chat, and whether the social aspect of multiple people chatting with agents at the same time - or the AI-specific features like skills, filesystem access, and browsing the AI's outputs in the sidebar become the stronger factor.

One possibility is that AI apps end up looking more like chat apps, and chat apps end up looking more like AI apps until they converge into a single communication and delegation app.

Open Standards Will Converge

Protocols like MCP, A2A, AP2, ACP, AG-UI, etc are all gaining traction quickly.

Open standards landscape: established agent protocols on top, and three unstandardized gaps below — memory, context, and agent infrastructure.
Established agent protocols on top, and three unstandardized gaps below: memory, context, and agent infrastructure.

My personal favorite as a Zed enthusiast is ACP (Agent Client Protocol). In Thunderbolt, my team built in first-class support for ACP to connect to agents like OpenClaw or Hermes Agent. This was a strategic choice based on a future where there's a clear separation between client and agent.

Client and agent separation via ACP: multiple chat clients connect over ACP to a separately hosted agent that holds memory, context, and an execution environment.
Multiple chat clients connect over ACP to a separately hosted agent that holds memory, context, and an execution environment.

Hopefully we'll also see new standards emerge in other areas:

Memory: currently there's no standard protocol for agent memory or shared context. Most memory implementations directly use custom APIs and libraries and key-value storage, creating tight coupling and vendor lock-in.

Context: context management over time and between agents is highly unstandardized and messy. Cloud-managed agents can use virtual filesystems or headlessly use Obsidian CLI, enabling real-time context syncing. I myself have been dabbling in approaches here with something I uncreatively labeled Context Sync Protocol, a tool that enables git-based version control, realtime syncing, instant point-in-time rollbacks, and automatic conflict-free merges inspired by CRDTs.

Agent Infrastructure: There's not yet a standardized API specification for spinning agents up and down and orchestrating the environments that they run in. There's a lot of work being done right now around providing execution environments and search for agents by companies like Modal, Tinfoil, Daytona, and E2B - but each provides a unique API. I'd love to see a standard here where I can connect to any AI infra provider and know that it will export a universal set of endpoints to spin up an agent, connect to that agent via ACP, and call a standard search endpoint.

Enterprise Will Value Open-Source

Enterprise is one place where open-source agents actually make the most sense outside of the homelab hacker crowd. The average consumer is fine with spinning up a cloud agent and entrusting Anthropic / OpenAI / Siri / Copilot. Enterprises in regulated industries have more nuanced concerns and there are many cases where self-deployable open-source tooling is critical: see RedHat and Canonical.

Relatedly, verifiable infrastructure via Trusted Execution Environments offers similar data guarantees with a different approach. And then there's always SOC-2 and HIPAA which have evolved from enterprise niches to expected standards.