Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • Start Here4
  • UVM Foundations14
  • UVM Phases & Simulation Lifecycle26
  • Factory & Configuration15
  • Transaction-Level Modeling (TLM)13
  • UVM Sequences & Stimulus21
  • UVM Agents & Protocol VIP21
    • Agent Architecture
      • What an Agent Owns, and What It Shows the World
      • Agent Configuration: Knobs, Config Objects and Who Owns Them
      • Mode-Gated Build: One Agent Class, Active or Passive
      • The Driver: Owning the Pins, One Transfer at a Time
      • The Monitor: Watch the Pins, Publish a Fresh Transaction
      • The Sequencer: The Agent's Stimulus Socket
      • Monitor Implementation Detail: Sampling, Races and X
      • Interface Abstraction: Virtual Interfaces vs Abstract BFMs
    • Reusable VIP: Active, Passive and Protocol Agents
    • Error and Fault Injection
    • Agent Patterns: Slaves, Reset, Interrupts and Pipelines
  • Environment & Test Classes11
  • Checking & Coverage in UVM21
  • UVM Register Abstraction Layer (RAL)22
  • Advanced UVM in Practice13
  • Debug & Regression10
  • Coding Practice47
  • Verification in Industry Practice10
  • Senior Prep: Architecture, Leadership and Interviews32
Loading lesson

‹UVM Agents & Protocol VIP
  1. Topics
  2. UVM Verification
  3. UVM Agents & Protocol VIP
  4. Agent Architecture

Part 6 · Agents & Protocol IP · Intermediate

Agent Architecture

What every UVM agent is made of: the wrapper, its config, mode-gated build, driver, monitor, sequencer, sampling rules and interface abstraction.

  • 8topics
  • 8lessons
On this page

    Every protocol in a UVM testbench gets the same box: an agent with a sequencer, a driver and a monitor, configured from outside and connected to the pins through an interface. This topic takes that box apart using the DMA bench's two real agents, apb_agent and axis_agent, so every claim is backed by code that runs.

    What you will be able to do

    • Name the three public surfaces of an agent (sequencer, analysis port, configuration) and explain why the env never reaches past them.

    • Configure an agent with knobs or a config object, and say who creates it and who wins when two components set it.

    • Write the mode-gated build that makes one agent class serve as an active driver at block level and a passive observer at chip level.

    • Write a protocol-correct driver and a monitor that publishes a fresh transaction per transfer, and explain the clock-edge timing behind both.

    • Choose between a virtual interface and an abstract BFM, and defend the choice for an emulation-friendly bench.

    How the lessons fit together

    Map of the agent: configuration feeds mode-gated build and the wrapper at time 0; at run time the sequencer feeds the driver, the driver drives the interface, the monitor reads it, and sampling rules apply to both driver and monitor.
    Each lesson owns one part of the agent. Configuration and build happen once at time 0; the sequencer, driver and monitor work every clock; the interface sits under both.

    #

    Lesson

    What it answers

    1

    What an agent owns

    The block diagram, the three public surfaces, and why ap = mon.ap works.

    2

    Agent configuration

    Knobs versus config objects, who creates them, and the shared-handle trap.

    3

    Mode-gated build

    How one class builds active or passive, get_is_active(), and extending an agent safely.

    4

    The driver

    Owning the pins: the APB waveform, reset parking, hooks, and the vanished write.

    5

    The monitor

    Recognising a completed transfer and publishing a fresh object to every subscriber.

    6

    The sequencer

    The agent's stimulus socket, when to write your own, and the passive agent's missing one.

    7

    Sampling, races and X

    Clocking blocks, #1step, the bench's race war story, SVA versus class checks, X policy.

    8

    Interface abstraction

    Virtual interfaces, parameterized interface typing, and the abstract-BFM pattern.

    Read them in order the first time: each lesson's "What breaks" section sets up the next one's problem. If you only have twenty minutes before an interview, read lessons 1, 4 and 7.

    Related topics

    • Up: Agents & Protocol VIP

    • Your first UVM testbench

    • The agent as the reuse unit

    PreviousNext: What an Agent Owns, and What It Shows the World

    Up next

    Up nextWhat an Agent Owns, and What It Shows the World

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Reusable VIP: Active, Passive and Protocol Agents
    • Error and Fault Injection
    • Agent Patterns: Slaves, Reset, Interrupts and Pipelines