Software for Agents: Designing for the Future

I remember the first time it hit me that the next trillion internet users wouldn’t be people, but AI agents. It was during a conference talk, and it made me pivot my entire approach to software design. We've been designing with human users in mind, but that’s not enough anymore. We need to think agent-first. Why? Because these AI agents aren’t some futuristic prediction—they’re our current reality. For us builders, this changes everything. Interfaces need to be machine-readable—think APIs, MCPs, CLIs—and documentation becomes crucial. And if you're in a startup, the market opportunities are massive. But watch out, don’t get swept up in the hype: there are pitfalls. I've taken a few hits while adapting my designs. So, if you don’t want to get left behind, now’s the time to rethink your approaches. Let’s explore how we can navigate this new digital era together.

Understanding AI Agents: The New Internet Users

AI agents are set to become the next trillion users of the Internet. Yes, that's trillion. It's a seismic shift. These agents don't click buttons like we do. They interact differently, and for them, efficiency and precision are key. I quickly realized that designing for these agents requires a different mindset. We have to ditch our need for visuals and focus on interfaces that machines can understand.

Switching from human-centric design to agent-centric design is like moving from driving a car to piloting a drone. You're not directly controlling anymore; you're configuring, orchestrating. And that changes everything. It's a bit like revolutionizing productivity with AI agents that directly understand your intentions.

Machine-Readable Interfaces: APIs, MCPs, and CLIs

APIs, MCPs, and CLIs are central to how agents interact with software. I embarked on setting up a machine-readable interface for our latest project. First, I integrated our API, then wrapped it in a service. And surprise, token usage exploded. So, I had to re-orchestrate the whole thing.

Watch out, when designing these interfaces, don't overdo it. Too much detail, and you lose performance. Too little, and the agent gets lost. It's about striking the right balance between human and machine readability. Once, I left out a detail, and it cost me hours of debugging.

Documentation: The Backbone of Agent Software

Documentation is the backbone of AI agent software. I learned the hard way that incomplete docs lead to failures. It's like building a house without a blueprint. So, I started documenting everything, from start to finish, so agents can navigate without human intervention.

Best practices? Always start with concrete examples. I use tools like Docusaurus to structure documentation, because it saves me tons of time. And ready-made templates, they're a real time-saver. Requesting feedback efficiently through good documentation is possible.

Market Opportunities: Building Agent-First Software

There's massive untapped potential in agent-first software. Startups have a real opportunity here. By building solutions that place agents at the center, we can revolutionize entire sectors. I've seen examples where agent-first applications have changed the game, like in supply chain 2.0.

But beware, developing for agents also means facing challenges. Sometimes it's trade-offs on performance or compatibility with existing systems. But with good orchestration, you can do wonders. And there, the business impact is direct.

Practical Takeaways: Designing for Efficiency and Orchestration

Efficiency is king when designing for AI agents. You have to orchestrate multiple interfaces so everything works in harmony. I've found it reduces costs and optimizes workflows.

Some cost-saving strategies:

• Automate testing and deployments as much as possible.
• Use orchestration tools like Kubernetes to manage workloads.
• Avoid common mistakes like code duplication or poorly managed dependencies.

Finally, always keep in mind that optimization is a continuous process. Every small improvement can have a significant impact on your daily operations.

Shifting to an agent-first mindset in software design isn't just about staying trendy; it's about future-proofing our work. First, I focus on machine-readable interfaces, like APIs, MCPs, and CLIs. This unlocks new market opportunities and streamlines operations. Next, documentation is the backbone of any agent software. It needs to be thorough so agents can navigate efficiently. And remember, the next trillion internet users will likely be AI agents. So let's anticipate and adapt our designs for these new players. It's a real game changer, but watch out for the trade-offs: it takes time to get an entire team aligned with this approach. Start integrating these practices today. It will put you ahead of the curve as AI agents become the dominant internet users. For more insights, I recommend watching the video "Software for Agents" on YouTube. It's like a chat between peers and will give you even more concrete ideas.