Architecture 2.0
Agentic Design Loops for Computing System Synthesis
Preface
Computer architecture has a new question. For decades the field asked what machines should be built for new kinds of computation. Capable AI systems now pose the reverse question: what can those systems do for the practice of architecture itself? This book is about that reversal and the claim that follows from it. The object an architect designs is no longer only the artifact. It is increasingly the design loop that produces, evaluates, rejects, and justifies the artifact.
I have made the broad case for this shift elsewhere. The foundations article with Amir Yazdanbakhsh argues why AI agents belong in modern computer system design and sets out the vision, history, ecosystem, capability horizons, and levels of autonomy that could follow (Janapa Reddi and Yazdanbakhsh 2025). This book starts where that argument ends. It does not set out to convince the reader that the shift is coming. It asks a more practical and more durable question. Once AI systems can act inside architecture work, how do we design loops we can trust, and how do we tell a real result from a confident demonstration?
That question is familiar from a different field. Machine learning systems faced the same credibility problem a decade ago. Claims were everywhere and comparison was hard. The answer was not a better model. It was measurement discipline: shared workloads, defined scenarios, provenance, and rules that made a performance claim mean the same thing across systems. Benchmarking efforts mattered because they turned enthusiasm into evidence. Architecture 2.0 needs the same move one level up. The task is to make AI-assisted architecture claims as credible and comparable as the community learned to make AI-systems claims.
This book is written from the boundary between computer architecture, machine learning systems, benchmarking, and education. That boundary is where the central problem becomes visible. AI methods are powerful, but architecture progress depends on hardware and software interfaces, workload definitions, toolchains, evidence standards, and human judgment. My work across architecture, edge and machine learning systems, benchmarking, and machine-learning-systems education shapes the emphasis here on loops rather than on isolated models.
The argument is therefore data-centric in a specific sense. The limiting question is not only which model or agent is used. It is which parts of architecture work are made observable: workload traces, design artifacts, tool outputs, constraints, rejected candidates, failed runs, and the provenance that ties feedback to a decision. Data-driven methods become credible only when the data records the design loop, not just its successful endpoints.
What follows is an operating framework, not a catalog. The field is moving quickly, and a catalog of today’s agents, tools, and benchmarks would age before it was useful. The durable contribution is a way to describe an architecture design loop, judge its evidence, and decide what the architect still owns. The framework has five pieces: task and intent, representation and world model, tools and environment, the compound agent and method system, and feedback, evidence, and decision. Around those pieces the book builds reusable objects: a claim grammar, a design-loop card, feedback and fidelity ladders, evidence chains, rejection authority, and a boundary for nondelegable judgment. The faster-moving record of who is doing what belongs with the community now forming around this topic. The book keeps the parts meant to last.
The reader I have in mind is plural. A graduate student entering the area should find the vocabulary and the lay of the land. A reviewer should find a way to ask what a project exposes and what could reject its result, not only what result it reports. An instructor should find artifacts that make the framework teachable: cards, checklists, and a paper-to-loop exercise. A practitioner should find a way to reason about where an agent may act and where the architect must still decide. If the book succeeds, each of these readers should be able to do something afterward that was harder before: name a loop, judge its evidence, and state what remains a human commitment.
AI systems do not remove the architect. They raise what the architect must be good at. The work moves upward, toward intent, representation, evidence standards, rejection authority, and accountability for the final decision. The opportunity is not to wait for a system that designs a computer from a single sentence. It is to change the unit of architectural practice from the isolated artifact to the represented, instrumented, evidence-bearing design loop, and to build loops worthy of an architect’s judgment.
Vijay Janapa Reddi
Acknowledgments
This lecture grew out of work and conversations across computer architecture, machine learning systems, benchmarking, and education. I am grateful to the students, collaborators, colleagues, and broader research community who pressure-tested the framing, challenged weak claims, and insisted on evidence over enthusiasm. Their questions and examples shaped the emphasis on design loops, evidence standards, rejection, and human architectural judgment throughout the book.
Any errors that remain are my own.