Explore six research modules at the intersection of AI and computing. Start with a module that interests you, then choose one concrete question to investigate (you are welcome to propose your own).
The ideas below are starting points for teams of 1–3 students. Select one principal mechanism, establish strong baselines, and evaluate benefits and limitations within an agreed scope.
Computing for AI
Develops the systems, architectures, and hardware that emerging AI workloads need.
Project Module 1
Computing Systems for Agentic AI
AI agents perform extended tasks through sequences of model calls, tool use, planning, and verification. Their execution can branch, pause, retry, and share state, creating resource demands that change throughout a task. The systems challenge is to coordinate these activities across compute, memory, and external tools while managing variable latency, state growth, and failures. Projects in this module investigate workflow execution, memory management, resource allocation, and recovery. Our goal is to complete more tasks correctly within practical latency and cost budgets. Better systems could make long-running coding assistants, research agents, and multi-agent applications more responsive, scalable, and dependable.
- Helpful background
- ML systems, operating or distributed systems, memory management, agent frameworks.
- Evidence of success
- Task success, end-to-end and tail latency, correct completions within a time target, memory use, and cost per successful task under realistic load.
Explore project ideas (4)
for Project Module 1: Computing Systems for Agentic AI
-
Memory management for long-running agents
Decide when to retain, offload, or recompute an agent's key-value (KV) cache while it waits for tools. Investigate whether return-time uncertainty and recovery cost improve decisions under memory pressure.
Detailed brief · StateValue
Value-Based KV Retention Across Agent Tool Gaps
While an agent waits for a tool, when is its idle KV state worth keeping, offloading, or recomputing later?
- Mechanism to explore
- Estimate retention value from uncertain return times, restore and recomputation costs, remaining workflow value, and memory pressure.
- Semester scope & evaluation
- One serving engine and two tool-gap distributions. Compare least-recently-used, fixed and adaptive time-to-live, and cost-aware caching; measure completion time, goodput, memory use, and transfer costs.
- Key check
- Go beyond adding a timeout. Isolate the value of return-time uncertainty, storage tiers, or workflow completion value relative to strong cache baselines.
- Helpful background
- ML systems · Memory systems
-
Dynamic workflow execution and scheduling
Coordinate model calls and tool execution as dependencies emerge. Choose a focused mechanism such as selective resource preparation, critical-path scheduling, or backpressure between GPU inference and CPU tools.
Detailed briefs · BranchServe, ToolCritical
Uncertainty-Aware Preparation for Dynamic Agent Workflows
When an agent's next step is uncertain, when is preparing resources early worth the risk of wasted work?
- Mechanism to explore
- Combine next-call probabilities, preparation cost, memory pressure, and expected latency savings to choose which model or KV states to prepare.
- Semester scope & evaluation
- One dynamic coding or tool-use agent and two resource types. Compare no preparation, top-1 prediction, frequency heuristics, and a future-information oracle; measure end-to-end gains and wasted preparation.
- Key check
- Prediction accuracy is not the objective. Reconstruct dependencies from observable events, not merely from their temporal order.
- Helpful background
- ML systems · Agentic AI
Joint Scheduling of LLM Calls and External Tools
When does speeding up model inference merely move the bottleneck to the tools an agent depends on?
- Mechanism to explore
- Estimate a shared critical path across model calls and tools; use admission control and backpressure to coordinate upstream generation with tool capacity.
- Semester scope & evaluation
- A coding agent's generate–compile–test workflow, initially limited to GPU and CPU resources. Compare independent queues, LLM-only scheduling, and simple backpressure; measure task completion and queueing across both stages.
- Key check
- Identify the load regimes where coordination helps or hurts. Higher GPU utilization alone does not establish a system benefit.
- Helpful background
- Systems · Agentic AI
-
Adaptive reasoning and verification budgets
Use runtime evidence to decide where additional model effort or verification is worth its cost. Study how these choices affect downstream errors, task completion, and resource use.
Detailed brief · VerifyBudget
Online Allocation of Verification Effort
Which intermediate checks prevent costly downstream errors, and which only add delay?
- Mechanism to explore
- Use runtime evidence to estimate error risk and avoidable downstream work, then choose no check, a lightweight check, or a stronger verifier.
- Semester scope & evaluation
- One code or constraint-solving workflow with objectively checkable outcomes. Compare verify-all, fixed placement, random placement, and an offline allocation policy at matched budgets.
- Key check
- Isolate the value of new runtime information. Evaluation labels must never be available to the online decision policy.
- Helpful background
- Agentic AI · ML systems
-
Reliable execution and selective recovery
Track dependencies and state changes to identify which steps must be replayed after a failure. Reduce repeated work while preserving both task correctness and consistent external state.
Detailed brief · RecoverGraph
Dependency-Aware Recovery for Stateful Agents
After a tool fails, what can an agent safely keep, and what must it undo or replay?
- Mechanism to explore
- Track file versions, tool inputs and outputs, and side effects to identify invalidated dependencies and selectively roll back or replay affected steps.
- Semester scope & evaluation
- Inject failures in an isolated file-and-test environment. Compare full restart, fixed checkpoints, and local retries; measure recovery correctness, duplicate side effects, and recomputation cost.
- Key check
- Validate both task completion and the final external state. Passing a test does not prove that recovery left no inconsistent side effects.
- Helpful background
- Systems · Agentic AI
Project Module 2
Computing Systems for Physical AI
Physical AI connects perception, prediction, and reasoning to actions in a changing environment. World models, vision-language-action models, and other controllers must operate within physical deadlines and limited compute, memory, and energy. More computation can improve a prediction while delaying the action that depends on it; compression or reuse can save resources while changing behavior. Projects in this module study these interactions through runtime optimization, memory systems, reliability, and hardware–software co-design. Our goal is to improve task success and responsiveness under resource constraints. The potential impact is more capable and efficient robots and autonomous systems that can operate on practical edge platforms.
- Helpful background
- Physical AI, robotics, ML systems, computer architecture, accelerators, VLSI.
- Evidence of success
- Closed-loop task success, completion time, deadline misses, and energy or memory cost. Execution delays and approximation errors should affect the evaluated control loop.
Each idea is a starting point to narrow further: choose one principal mechanism. Compression and resilience, for example, can become separate projects.
Explore project ideas (5)
for Project Module 2: Computing Systems for Physical AI
-
Adaptive planning and timely action
Allocate candidate trajectories or planning iterations according to remaining time and expected decision benefit. Alternatively, study when an asynchronous controller should finish an existing inference or restart from a fresher observation.
Detailed briefs · PlanBudget, FreshAct
Deadline-Aware Compute Allocation for World-Model Planning
When does thinking longer improve an action, and when does it make the observation too stale to act well?
- Mechanism to explore
- Use action disagreement, recent planning gains, and remaining time to allocate candidate trajectories and optimization iterations; initially keep the planning horizon fixed.
- Semester scope & evaluation
- One pretrained model and two environments. Compare tuned fixed budgets, convergence-based early stopping, and time-budget heuristics; measure success, completion time, and deadline misses with inference latency inside the control loop.
- Key check
- First test whether inexpensive signals predict the marginal value of more planning. If not, narrow the policy to a few identifiable task states.
- Helpful background
- Physical AI · ML systems
Freshness-Aware Scheduling for Asynchronous Robot Inference
When new information arrives during inference, is it better to finish an old decision or start a fresher one?
- Mechanism to explore
- Incorporate observation age, action validity, and task stage into either cancel-or-continue decisions or action-chunk sizing; choose one control axis first.
- Semester scope & evaluation
- Use one vision-language-action or world-model controller with injected latency and jitter. Compare synchronous inference, a fixed asynchronous policy, latest-observation-first, and applicable asynchronous methods.
- Key check
- Let delays change the environment state. Timing inference while the simulator is paused cannot establish the value of freshness.
- Helpful background
- Physical AI · Systems
-
Memory and computation reuse across time
Reuse valid scene representations, context encodings, or planning results across control steps. Develop one retention or refresh policy that accounts for how stale information affects downstream decisions.
Detailed briefs · RolloutReuse, SceneBudget
Reusing Computation Across World-Model Planning Steps
As observations and actions change, which parts of a previous plan remain valid enough to reuse?
- Mechanism to explore
- Separate exact reuse of invariant goal or context computations from approximate reuse of predicted states; use observation residuals to decide when to refresh.
- Semester scope & evaluation
- Implement one exact and one approximate reuse mechanism in a single planner. Compare no reuse, action-sequence warm starts, and periodic refresh; include lookup, validation, and recomputation costs.
- Key check
- Similar trajectories do not imply cacheable intermediate states. Establish what the model actually permits before building a cache.
- Helpful background
- ML systems · Architecture
Task-Aware Memory Management for 3D Scene Representations
Under a memory limit, which scene details are worth keeping because they change what an agent can do?
- Mechanism to explore
- Use planned paths, interaction regions, and query distributions to prioritize retention or precision of occupancy blocks or Gaussian primitives; choose one representation.
- Semester scope & evaluation
- One scene system and one downstream task. At equal memory budgets, compare least-recently-used, distance-based, and visibility-based policies; measure task quality, query latency, and reconstruction cost.
- Key check
- Rendering quality alone is not enough. Demonstrate how memory decisions affect planning, avoidance, or interaction.
- Helpful background
- Architecture · Physical AI / Graphics
-
Decision-aware compression and resilience
Identify which numerical changes alter action selection or task outcomes. Choose a focused study of mixed precision, selective protection, or error recovery, and measure the resulting efficiency–quality tradeoff.
Detailed briefs · RankPreserve, HorizonGuard
Decision-Preserving Quantization for World Models
Should a compressed world model preserve its predictions, or preserve the decisions those predictions support?
- Mechanism to explore
- Allocate layer precision using trajectory-ranking changes, action flips, and decision margins rather than reconstruction error alone.
- Semester scope & evaluation
- Fix one planner and compare uniform quantization, reconstruction-based mixed precision, and decision-based mixed precision. Test held-out tasks and planning horizons; trace numerical error through action selection to control quality.
- Key check
- Report measured low-precision speedups separately from simulated precision benefits when the target kernels are unavailable.
- Helpful background
- ML systems · Architecture / VLSI
Temporal Fault Protection for World-Model Rollouts
Which faults matter most when a prediction is repeatedly fed into future predictions and decisions?
- Mechanism to explore
- Trace error propagation across states and time steps, then selectively protect, detect, or recompute computations with high decision sensitivity.
- Semester scope & evaluation
- Fix one model and planner and inject one fault family, such as memory bit flips. Compare uniform, layer-sensitive, and temporal protection; trace fault location through action changes to task outcomes.
- Key check
- Software fault injection does not establish real low-voltage energy savings; such claims require separate hardware calibration.
- Helpful background
- Architecture / VLSI · Physical AI
-
Architectures for world-model planning
Study the data reuse exposed by candidate trajectories, rollout steps, and planning iterations. Design and evaluate a memory organization, dataflow, or accelerator component around a measured bottleneck.
Detailed brief · RolloutMem
Memory Architecture for Batched World-Model Planning
How do candidate trajectories, time steps, and planning iterations change the memory reuse an accelerator should exploit?
- Mechanism to explore
- Profile real planning workloads and design tiling, scratchpad partitions, and state storage around the tradeoff between candidate parallelism and memory capacity.
- Semester scope & evaluation
- One predictor and two planner configurations. Validate a memory model, compare generic matrix-multiplication-oriented mapping with planning-aware mapping, and synthesize one key module for area and timing estimates.
- Key check
- Show structure beyond ordinary batched inference. The model must represent actual operators and dependencies rather than assume an extra reuse benefit.
- Helpful background
- Architecture · VLSI
-
Resource-aware deployment and robot serving
Investigate either energy management on one edge device or scheduling for multiple robots sharing compute. Use control requirements to guide resource decisions and evaluate their effect on completed tasks.
Detailed briefs · LoopWatt, FleetSlack
Closed-Loop Energy Management for Physical AI
Which combination of computation and hardware power minimizes energy to finish a task, rather than energy per inference?
- Mechanism to explore
- Jointly select a small set of inference budgets and frequency or power settings using task stage and control slack.
- Semester scope & evaluation
- One device and one control-task suite. Compare static settings, hardware-only control, algorithm-only control, and a joint policy; measure success, completion time, and total energy across all attempts per successful task.
- Key check
- Include controller, CPU, memory, and extra-action costs. Without reliable device-level power measurement, scope the project around latency and resource use instead.
- Helpful background
- Architecture · Physical AI
Control-Aware GPU Sharing for Multiple Robots
If two requests share a deadline but tolerate delay differently, how should they share a GPU?
- Mechanism to explore
- Estimate stage-specific control sensitivity and combine it with batching benefits to choose request priorities and batch windows.
- Semester scope & evaluation
- Start with 2–8 simulated clients on one shared GPU. Compare earliest-deadline-first, fixed batching, and load-aware batching; report per-robot success, fairness, tail latency, and task completion rate.
- Key check
- Use independently advancing clients or an explicit time model; pausing every robot together can overstate the benefit of sharing.
- Helpful background
- Systems · Robotics
Project Module 3
Computing Systems for Neuro-Symbolic and Compositional AI
Neuro-symbolic and compositional AI combines learned models with explicit rules, probabilistic reasoning, structured search, or other specialized components. This offers ways to incorporate constraints and domain knowledge into intelligent behavior, but it also creates heterogeneous computation: dense neural operations interact with irregular dependencies, sparse updates, and iterative reasoning. Data conversion and coordination can become as important as individual operators. Projects in this module explore incremental execution, efficient composition, and architectures for these workloads. Our goal is to reduce the cost of structured intelligence while preserving its intended semantics and task quality. Progress could make reasoning, planning, and constrained decision-making practical on a wider range of computing platforms.
- Helpful background
- Computer architecture, ML systems, neuro-symbolic AI, probabilistic models, VLSI, emerging memory.
- Evidence of success
- Reasoning correctness or task quality, latency, energy, and data movement across different graph structures, evidence changes, or composition patterns.
Explore project ideas (4)
for Project Module 3: Computing Systems for Neuro-Symbolic and Compositional AI
-
Incremental reasoning under changing evidence
Update only the portions of a reasoning graph affected by new observations or facts. Study when dependency tracking and cached intermediates outperform complete recomputation while preserving correctness.
Detailed brief · DeltaReason
Incremental Execution for Neuro-Symbolic Inference
When only a few facts change, how much reasoning truly needs to be repeated?
- Mechanism to explore
- Propagate evidence changes through affected dependencies, cache reusable intermediates, and switch between incremental and full execution based on the affected region.
- Semester scope & evaluation
- One probabilistic-circuit or rule-reasoning framework. Compare full recomputation, an existing incremental or memoization method, and an adaptive policy across update locality and graph structure.
- Key check
- First establish equivalence with full execution. Look for reasoning-specific effects such as normalization dependencies, pruning, or conflicts with GPU batching.
- Helpful background
- Architecture · Neuro-symbolic AI / ML systems
-
Heterogeneous execution of neural and symbolic components
Optimize communication, representation conversion, or scheduling between components with different execution patterns. Start with one pipeline and one interface or dataflow mechanism.
Detailed brief · ReasonLink
Data-Movement-Aware Integration of Neural and Symbolic Accelerators
After accelerating both ends of a pipeline, does the interface between them become the bottleneck?
- Mechanism to explore
- Combine compact intermediate representations, buffering, delta transfers, and producer–consumer overlap to reduce conversion, synchronization, and data-movement costs.
- Semester scope & evaluation
- One neural frontend and one simplified reasoning kernel. Build a calibrated system model and one RTL or high-level-synthesis module; compare serial transfers, double buffering, and the proposed interface.
- Key check
- The contribution should be an interface or dataflow mechanism. Make board-level integration a goal only when a working FPGA platform already exists.
- Helpful background
- VLSI · Architecture
-
Efficient compositional inference
Study one workload that combines models, constraints, or energy functions. Investigate a concrete bottleneck such as repeated sampling, shared intermediate computation, or inefficient batching across components.
-
Memory-centric architectures for structured reasoning
Explore compute-in-memory or associative hardware for a selected vector-symbolic or reasoning operation. Account for data movement, device errors, and peripheral costs when evaluating task-level benefits.
Detailed brief · MarginCIM
Decision-Margin-Aware Reliability for Associative Computing
Can hardware protection focus on numerical errors that would actually change a decision?
- Mechanism to explore
- Use the margin between candidate matches to selectively repeat reads, raise precision, or strengthen error correction for vulnerable associative queries.
- Semester scope & evaluation
- One vector-symbolic or associative-search workload and an explicit device-error model. Compare uniform protection, uniformly reduced precision, and margin-aware protection, including sensing and digital-periphery overhead.
- Key check
- Distinguish fixed bias, random read noise, and correlated errors; an independent Gaussian-noise sweep alone is not a sufficient reliability model.
- Helpful background
- VLSI · Emerging memory
AI for Computing
Uses AI to design, optimize, and verify the computing stack itself.
Project Module 4
AI for Software Systems
Software performance depends on many interacting choices, from kernel implementations and compiler transformations to runtime configuration and resource allocation. These choices are difficult to optimize across changing workloads and hardware, and an apparently faster component may introduce errors or fail to improve the full application. AI can help navigate this space by inspecting programs, interpreting performance evidence, and proposing testable changes. Projects in this module build and evaluate such optimization agents with compilers, profilers, tests, and execution environments in the loop. Our goal is to produce correct, measurable software improvements within a limited optimization budget. The potential impact is more efficient applications and less manual effort in performance engineering.
- Helpful background
- Systems programming, CUDA, compilers, performance profiling, ML systems, agentic AI.
- Evidence of success
- Correctness, application-level performance, optimization cost, and transfer across workloads or configurations, compared with strong non-agentic methods.
This module studies AI as the optimizer of software systems; Project Module 1 studies the systems that execute AI agents.
Explore project ideas (4)
for Project Module 4: AI for Software Systems
-
GPU kernel generation and optimization
Use AI to optimize a real bottleneck in an AI pipeline while respecting shapes, layouts, and numerical requirements. Compare against compiled frameworks and optimized libraries, and measure end-to-end effects.
Detailed brief · KernelContract
Contract-Aware GPU Kernel Optimization Agents
What must an optimized kernel preserve for a microbenchmark speedup to become a correct end-to-end improvement?
- Mechanism to explore
- Give the agent explicit constraints on data type, layout, dynamic shapes, aliasing, numerical tolerance, and invocation patterns; prioritize actual pipeline bottlenecks.
- Semester scope & evaluation
- Optimize 3–5 hotspots in a world-model or neuro-symbolic pipeline. Compare a generic kernel agent, profiler-only feedback, and contract-aware optimization, alongside compiled-framework and optimized-library baselines.
- Key check
- Identify a workload-specific cross-operator constraint or mechanism. End-to-end measurement is necessary but is not, by itself, the research contribution.
- Helpful background
- CUDA / Compilers · Agentic AI
-
Compiler and program optimization
Guide a bounded set of compiler passes, fusion decisions, or program transformations using code structure and execution feedback. Test correctness and performance on held-out programs or input configurations.
-
Performance diagnosis through targeted experiments
Build an agent that uses traces and profiles to propose bottleneck explanations and select experiments that distinguish them. Evaluate whether the resulting diagnosis leads to an effective fix.
-
Adaptive runtime and serving configuration
Use AI to recommend or adjust a small set of runtime settings as load changes. Study one mechanism for adaptation, accounting for monitoring, decision, and reconfiguration costs.
Project Module 5
AI for Computer Architecture
Computer architects must connect workload behavior to design mechanisms while balancing performance, energy, area, and implementation constraints. The design space is large, detailed simulation is expensive, and good decisions require explanations that survive experimental testing. AI agents may help analyze workloads, formulate hypotheses, explore designs, and reuse knowledge across tasks. The challenge is to turn this assistance into valid architectural improvements with reliable predictions and efficient use of evaluation resources. Projects in this module study agents working with architecture models and simulators. Our goal is to improve design quality and reduce exploration cost, creating methods that help architects discover and assess useful mechanisms across changing workloads.
- Helpful background
- Computer architecture, simulators, accelerators, compilers, optimization, agentic AI.
- Evidence of success
- Validated design quality, prediction accuracy, search cost, and generalization under matched compute and tool budgets. Final claims should follow from independently evaluated designs.
Explore project ideas (4)
for Project Module 5: AI for Computer Architecture
-
Hypothesis-driven architectural exploration
Require an agent to predict the effect of a design change before running an experiment. Study whether targeted interventions and prediction updates improve design quality under a fixed budget.
Detailed brief · CausalArch
Hypothesis-Driven Experiments for Architecture Agents
Can an agent use experiments to distinguish competing explanations, rather than explain a design only after seeing its score?
- Mechanism to explore
- Require performance predictions and bottleneck hypotheses before each run; select interventions that distinguish explanations and update beliefs when predictions fail.
- Semester scope & evaluation
- Two small architecture-evaluation tasks. Compare a standard agent loop, structured reflection, Bayesian optimization, and explicit experiment design; measure design quality, prediction calibration, and the cost of identifying bottlenecks.
- Key check
- Keep the model, tools, and budget fixed. The contribution is better experimental choices, not longer reasoning or more runs.
- Helpful background
- Architecture · Agentic AI
-
Efficient use of simulation fidelity
Decide when an analytic estimate, short trace, or detailed simulation provides enough evidence to advance or reject a candidate. Validate final designs at the highest selected fidelity.
Detailed brief · FidelityDSE
Cost-Aware Selection of Evaluation Fidelity
How much evidence is enough to reject a design, and when is a more faithful evaluation worth its cost?
- Mechanism to explore
- Estimate bias and uncertainty across analytic models, short traces, and full simulation; selectively promote candidates to higher-fidelity evaluation.
- Semester scope & evaluation
- One design space and 2–3 fidelity levels. Compare a fixed pipeline, successive halving, multi-fidelity Bayesian optimization, and agent-assisted selection; validate every final candidate at the highest fidelity.
- Key check
- Count API, simulation, and wall-clock costs. Isolate whether design structure or failure explanations add value beyond established multi-fidelity search.
- Helpful background
- Architecture · ML / Optimization
-
Transferable accelerator mapping knowledge
Turn successful and failed mappings into reusable guidance with explicit applicability conditions. Evaluate transfer to unseen workloads, tensor shapes, or hardware resource configurations.
Detailed brief · MapTransfer
Reusable Mapping Knowledge for AI Accelerators
Can a good accelerator mapping become reusable knowledge with clear limits, rather than a configuration that works only once?
- Mechanism to explore
- Turn successful and failed mappings into constrained templates with explicit applicability conditions; match new workloads to templates and refine locally.
- Semester scope & evaluation
- One mature mapping platform. Compare a memoryless agent, nearest-neighbor reuse, a classical mapper, and template-guided search on held-out model families, shape ranges, or memory capacities.
- Key check
- Test genuine transfer. Reusing near-duplicate configurations or simply adding past answers to a prompt is not enough.
- Helpful background
- Architecture · Compilers / Agentic AI
-
Workload-driven ISA and accelerator extensions
Use AI to propose a small extension from an application hotspot, then evaluate its software use, functional correctness, and hardware cost. Start with one processor and one workload family.
Detailed brief · ISABenefit
Workload-Driven, Verified RISC-V Instruction Discovery
What makes a new instruction worth adding once software use, hardware cost, and end-to-end impact are all counted?
- Mechanism to explore
- Propose a few extensions from application hotspots, connect them through intrinsics, verify their semantics, and select for area-constrained system benefit.
- Semester scope & evaluation
- One core, one workload family, and at most three candidates. Compare the standard instruction set, manually selected hotspot fusion, and search- or agent-selected extensions; include synthesis and held-out inputs.
- Key check
- Focus on selecting useful extensions, not merely integrating RTL. Count critical-path effects, data movement, and how often software can use the instruction.
- Helpful background
- Architecture · VLSI / Compilers
Project Module 6
AI for Chip Design
Chip design translates intended behavior into hardware that must satisfy functional, timing, power, area, and physical constraints. Progress often depends on specialized expertise and repeated interactions with verification, synthesis, simulation, and implementation tools. AI can assist with generating changes, interpreting failures, and deciding what to try next, but useful automation must preserve specifications and produce designs that withstand independent checking. Projects in this module explore bounded tasks in digital and analog design with tool feedback in the loop. Our goal is to improve verified design quality and reduce iteration cost. The potential impact is a more accessible and efficient path from design intent to implementable hardware.
- Helpful background
- Digital or analog IC design, RTL, formal verification, physical design, EDA, computer architecture.
- Evidence of success
- Functional or specification correctness, relevant circuit or PPA metrics, tool cost, and robustness across designs or operating conditions. A semester project may use simulation and synthesis; tapeout is not required.
Explore project ideas (5)
for Project Module 6: AI for Chip Design
-
Verified RTL optimization
Start from correct RTL and use AI to propose local changes that improve power, performance, or area. Apply equivalence checking against a fixed reference before accepting an optimization.
Detailed brief · ProofFirst
Verified RTL Optimization Under Fixed Specifications
Can an agent improve hardware efficiency while keeping the functional specification completely fixed?
- Mechanism to explore
- Start from correct RTL, propose local transformations, and use formal-equivalence counterexamples to guide repair; evaluate power, performance, and area only after verification passes.
- Semester scope & evaluation
- Small arithmetic modules, FIFOs, or arbiters. Compare default synthesis, simulation-only feedback, and formal-guided optimization; report equivalence pass rate, PPA, verification time, and timeouts.
- Key check
- Isolate the specification and verifier from agent edits. Make reset behavior, temporal equivalence, and environmental assumptions explicit; a timeout is not a proof.
- Helpful background
- VLSI / Formal methods · Agentic AI
-
Hardware debugging and repair
Combine RTL structure with failing assertions, waveforms, or simulation evidence to locate and repair a specific class of bugs. Verify fixes against tests or properties unavailable during repair.
Detailed brief · ConeRepair
Dependency-Grounded Repair of RTL Repositories
Which structural and runtime evidence helps an agent locate the logic responsible for a cross-module hardware failure?
- Mechanism to explore
- Combine module hierarchy and signal dependencies with failing assertions or waveforms; use the resulting cone of influence to focus edits and reverify repairs.
- Semester scope & evaluation
- One bug class in two small open-source designs. Compare text retrieval, vector retrieval, HDL-graph retrieval, and failure-guided retrieval using repository-level holdouts.
- Key check
- Isolate the value of dynamic failure evidence beyond structural retrieval. Report historical bugs separately from injected mutations.
- Helpful background
- VLSI · Agentic AI
-
Physical-design optimization
Use timing and congestion reports to guide a restricted set of implementation decisions. Evaluate valid-design rate and physical metrics across several blocks under matched tool budgets.
Detailed brief · TimingPilot
Report-Grounded Agents for Physical-Design Closure
Can understanding why a design violates constraints make an agent more effective than treating the design flow as a black box?
- Mechanism to explore
- Map critical-path, congestion, and violation reports to a limited action set such as placement density, buffering, or selected flow parameters; track the effects of each change.
- Semester scope & evaluation
- One fixed tool flow and several small blocks. Compare defaults, Bayesian optimization, a score-only agent, and a report-grounded agent; measure valid-design rate and PPA under matched budgets with held-out designs.
- Key check
- Fix tool and process-design-kit versions. A good parameter setting on one block does not demonstrate a transferable optimization strategy.
- Helpful background
- VLSI / Physical design · Agentic AI
-
Workload generation for power characterization
Generate legal programs that exercise underexplored activity patterns in a processor. Compare coverage and power estimates with random, coverage-guided, or evolutionary search, and validate the measurement model.
Detailed brief · PowerProbe
Goal-Conditioned Workload Synthesis for Power Characterization
Which legal program behaviors do standard workloads miss when characterizing power and rapid power changes?
- Mechanism to explore
- Generate programs against explicit power-profile goals and coverage gaps, then refine them using simulation and power feedback rather than a single maximum score.
- Semester scope & evaluation
- One small RISC-V core and two targets, such as average dynamic power and windowed power change. Compare random, coverage-guided, and evolutionary search; retain reproducible programs and validate high-fidelity results separately.
- Key check
- Switching activity is a proxy, not a measurement of voltage droop or worst-case chip power. State precisely what the evaluation supports.
- Helpful background
- VLSI · Architecture / Agentic AI
-
Analog and mixed-signal circuit optimization
Use simulation feedback to optimize sizing or bias choices in one small circuit with a fixed topology. Check specification satisfaction across selected process, voltage, and temperature conditions.
Choosing a project
Select one idea and narrow it to one testable hypothesis, one principal mechanism, and a manageable evaluation platform. Agree on scope, available tools, and resource needs with the instructor before committing. A typical starting point is one model, runtime, simulator, or design family with strong baselines and an additional held-out condition.
The modules describe research opportunities; they do not prescribe a solution. Cross-module projects are welcome when the contribution remains clear. Research quality is judged through sound reasoning, careful experiments, and reproducible evidence, including informative negative results. Publication is an aspiration, not a grading requirement. For cross-module work, make each team member's contribution explicit.