The conversation about software architecture has shifted from how systems compute to how they decide, and that distinction matters more than most professionals realize. Rafał Gancarz's series on agentic AI architecture makes a compelling case that this new paradigm will define the next era of software development, and we agree, not because the technology is flashy, but because it addresses a fundamental limitation in how we build systems today.
Traditional architectures treat every interaction as a function call: input goes in, output comes out, and the system has no awareness of context or intent. Agentic architecture changes that by designing for decisions rather than execution. This is not a minor upgrade. It is a rethinking of what software can do when it understands its environment, sets goals, and adapts its behavior accordingly. As we explored in our piece on Designing distributed systems for decisions, not just functions, the move from microservices to agent-based models is already underway in organizations that need systems to operate with autonomy rather than rigid scripts. The difference is practical: a function-based system breaks when the input changes; a decision-based system learns and adjusts.
What makes this shift feel tangible rather than theoretical is how quickly it is moving from research into production. The same week we read about agentic architectures entering the mainstream, we also saw how Eka Robotics shows how physical AI can handle delicate tasks with human-like precision. That robotic arm does not follow a pre-programmed sequence of movements, it perceives, decides, and adapts in real time. That is agentic architecture applied to the physical world. The connection is direct: if you can build a system that picks up unfamiliar objects without explicit instructions, you can build a spreadsheet that anticipates your next analysis step without a macro. The underlying logic is the same, just applied to different domains.
For anyone working with data tools today, the practical takeaway is straightforward: the software you rely on will soon need to act on your behalf, not just respond to your commands. This is not about replacing human judgment. It is about removing the friction of translating intent into keystrokes. Agentic architecture does not promise to think for you; it promises to understand what you are trying to accomplish and handle the repetitive reasoning that currently slows you down. The question that remains open is how much autonomy we trust these systems to exercise. A function that returns a wrong number is easy to debug. A decision that leads to a wrong outcome is harder to trace, especially when the system has adapted its behavior over time. That is the specific challenge we will watch as this architecture matures: not whether it works, but how transparent its reasoning will be when it matters most.