Architecture 2.0 Workshop & Tutorial

About the Workshop & Tutorial

The Architecture 2.0 workshop and tutorial brings together researchers and practitioners exploring the intersection of agentic artificial intelligence and computer systems. As autonomous agents and AI workflows continue to transform how we design, optimize, and evaluate computing systems, this combined event provides a venue for presenting cutting-edge research and fostering collaboration on agent-based methodologies across the hardware stack.

The workshop and tutorial focuses on Agentic AI for Systems Design, spanning computer architecture, programming languages, and operating systems. We aim to bring together researchers and practitioners applying agentic tools and autonomous AI techniques to systems challenges, providing a platform for work-in-progress and completed research that advances the state of the art or opens new directions for agent-driven systems engineering.

The event consists of two main components: a Call for Papers for research submissions, and a Call for Tutorials for hands-on demonstrations. Both are part of the same combined program.

📅

Date

Saturday, June 27, 2026

📍

Location

ISCA 2026 · Raleigh, NC

Call for Papers: Agentic AI for Architecture & Systems Design

We invite submissions that explore the use of agentic frameworks, autonomous workflows, and artificial intelligence to design, analyze, optimize, or evaluate computer systems. The workshop and tutorial aims to bring together researchers and practitioners applying agent-based AI techniques to systems challenges across the hardware stack.

We welcome both work-in-progress and completed research that advances the state of the art or opens new directions for agent-driven hardware methodologies and systems research.

Note: The event will not have formal proceedings, and authors are free to publish extended versions of their work in other conferences and journals.

Submission Type

We welcome works of three different formats:

Early/Work-in-Progress Research (4 Pages)
Extended Abstract of Completed Research (2 Pages, with pointer to full-length paper)
Position/Opinion Papers (2 Pages)

Topics of Interest

Submissions should focus on AI for Systems, spanning computer architecture, programming languages, and operating systems, including but not limited to the following areas:

Computer Architecture

Agent-driven microarchitecture design, tuning, and exploration
Agent-driven chip design, hardware code generation, synthesis, and place-and-route
Agent-driven design space exploration and architectural trade-off analysis
Agent-optimized processor, accelerator, and heterogeneous system design
GPU, TPU, and accelerator architectures and kernel optimization via autonomous agents
Memory systems, cache hierarchies, interconnects, and storage optimization using agentic AI
Agent-based performance, power, energy, and reliability modeling
Agentic workflows and surrogate models to accelerate architectural simulation and evaluation
Autonomous methods for identifying architectural bottlenecks and inefficiencies

Systems

Agent-assisted compilers, program analysis, and code generation
Automatic kernel transformation, scheduling, and tuning
Cross-layer co-design across compilers, runtimes, operating systems, and hardware via agentic workflows
Agent-driven scheduling, resource management, and system-level optimization
Intelligent and autonomous runtime systems for heterogeneous and accelerator-rich platforms
Agent-driven memory management, caching, and I/O policies

Infrastructure and Evaluation

Datasets tailored for agentic hardware and systems evaluation
Benchmarks for assessing agent-driven system workflows
Open-source infrastructure enabling agent-driven approaches across the architecture–language–OS stack

Reviewing Details

Submission and Platform: All submissions will be handled through the OpenReview platform. The review process will be single-blind; therefore, submissions should include author names and affiliations and should not be anonymized.

Decisions: All accept/reject decisions will be made exclusively by the human members of the organizing committee. Submissions will be evaluated for relevance to the event\'s themes theme, technical novelty, and clarity of presentation.

AI-Assisted Feedback: In alignment with the workshop's focus on leveraging AI, the organizing committee will pilot ArchScholar, an AI-based review assistant that is custom-built on Archipedia: a corpus of computer architecture and systems literature spanning 50 years. This tool will be used to generate preliminary written feedback and reviews, which will be publicly posted on OpenReview. Importantly, the AI-assisted tool is used solely to support the review process and to provide individualized written feedback to authors; it does not determine final decisions. We welcome feedback from the community and hope to encourage thoughtful, constructive discussion around the use of AI-assisted reviewing as part of the program.

Submission Details

Submission deadline: May 8, 2026 (AoE)

Author Notification: May 22, 2026

Paper length:

Early/Work-in-Progress Research: 4 pages
Extended Abstract of Completed Research: 2 pages (with pointer to full-length paper)
Position/Opinion Papers: 2 pages

(Page counts exclude references and appendix)

Format: Standard ISCA 2026 Latex Template

OpenReview Submission Site

Call for Tutorials & Demos

We invite the community to submit proposals for short mini-tutorials, tool demonstrations, and hands-on sessions. This is a great opportunity to showcase your agent-driven tools, simulation frameworks, and open-source infrastructure to researchers and practitioners at the event.

Tutorials and demos should align with the theme of Agentic AI for Architecture & Systems Design and provide practical value or reproducible environments for the community.

Example Topics & Formats

We encourage interactive formats showcasing practical applications of agentic AI. Example topics include, but are not limited to:

Agentic Coding Assistants for Systems: Walkthroughs using Cursor, Copilot, or Claude CLI for hardware description languages (HDL), compiler passes, or systems codebase debugging.
Agent-Driven Architecture Tools: Live demonstrations of autonomous frameworks for microarchitecture design, synthesis, or design space exploration.
Autonomous Hardware/Code Generation: Interactive demos showcasing automatic kernel generation, accelerator design, or optimization using Large Language Models.
Agent-Assisted Verification & Testing: Tutorials on leveraging LLMs to write hardware testbenches, generate assertions, or discover system-level vulnerabilities.
Agentic Systems Optimization: Demos showcasing autonomous agents handling cluster scheduling, runtime resource management, or architecture power/performance tuning.
Agent-System Simulation & Platforms: Hands-on sessions focused on running architectural simulators, datasets, or benchmarking infrastructure tailored for agent workflows.