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

  • Getting Started with AI for VLSI Engineers5
  • Just Enough AI: Models and Context15
  • Prompting13
  • Trust and Verification14
  • Using AI for Engineering Work17
  • Engineering Walkthroughs7
  • Practical Foundations for AI Workflows4
  • Engineering Data5
  • Retrieval-Augmented Generation6
  • Agents and Tool Use18
  • Agent Design8
    • Define the Task and Boundaries
    • Design the Architecture
    • Build Safe Read-Only Tools
    • Control the Decision Loop
    • Record State and Hand Over
    • Handle Errors and Budgets
    • Build the Starter Controller
    • Evaluate Your Assistant
  • MCP and Skills6
  • Multi-Agent Design6
  • Practical Capstone6
  • Tokens, Cost and Latency12
  • Agentic Workflows for Chip Teams18
  • Interview and Judgment10
  • AI Skills: Full Course Index
  • Working with AI Glossary
  • Working with AI Cheatsheet
Loading lesson

‹Agent Design
  1. Topics
  2. AI Skills for VLSI Engineers
  3. Agent Design
  4. Record State and Hand Over

Agent Design · Beginner

Record State and Hand Over

Preserve evidence, unknowns, and useful next checks without hidden reasoning.

On this page

    The Problem: A Summary That Loses Its Evidence

    A handover saying 'reset probably broke in the latest RTL' sounds useful but omits the test, run, source lines, and comparison conditions. The next engineer must repeat the investigation. Store observable facts with references and keep hypotheses distinguishable from facts. The state should answer what was read, which snapshot it came from, what the tool returned, why the loop stopped, and which questions remain open. It should not request or retain private hidden reasoning.

    A Small State Contract

    The starter state includes a synthetic marker, fixture snapshot, goal, terminal status, choice count, evidence records, compact events, and unknowns. Evidence records carry E1-style references, source identifiers, rows, and truncation flags. Events identify the tool and outcome without copying arbitrary exception messages. The controller owns this state and supplies a deep copy of selected fields to the chooser. That reduces accidental mutation and gives a future model a compact, purposeful view rather than an unrestricted application object.

    Record

    Appropriate content

    Avoid

    Evidence

    E1, R42 log, line 2, observed_valid=1 expected_valid=0

    An unsupported diagnosis stored as a fact

    Unknown

    Whether cycle 12 is the first release edge

    An invented waveform observation

    Event

    Step 2, readspec, ok, E2

    Raw transport errors or sensitive payloads

    Handover

    Required human check and terminal status

    A transcript of hidden model reasoning

    Seven-node evidence map combines log, specification, history, unknowns, and events into a synthetic packet for human review; it contains no hidden reasoning.
    A useful handover combines source evidence, unresolved questions, and the actual stopping status.

    Worked Synthetic Handover

    plaintext
    1
    2
    3
    4
    5
    6
    7
    8
    9
    Illustrative handover, derived from fixture definitions; not a captured run:
    Scope: synthetic fixture-v1, reset_smoke, R42
    Observed: E1 log lines 1-2 report a cycle-12 reset_release failure,
              observed_valid=1 and expected_valid=0.
    Requirement: E2 lines 1-2, revision 3, valid stays 0 through first release edge.
    Comparison: E3 lists PASS in R40/a1 and R41/a2, FAIL in R42/a3, seed 17.
    Unknown: cycle-to-edge alignment, checker correctness, equivalent configuration.
    Next human check: inspect an approved waveform and confirm configuration identity.
    Status: handoff_requested. No root cause or fix established.

    History revision labels make the comparison more useful, but shared seed 17 is not proof of equivalence. Simulator options, testbench revisions, constraints, and reset stimulus may differ. The starter intentionally keeps configuration equivalence unresolved. For STA, a handover should similarly retain mode, corner, units, and path identities before comparing slack. For PD, congestion bins measured at different flow stages are not automatically comparable. The record should make such mismatches visible, not compress them into a misleading trend.

    The Python program returns a JSON evidence packet, not the prose handover above. A human or separately validated presentation layer can render it. If a future model writes a summary, require every factual claim to point to a recorded reference and check that the referenced text actually supports the claim. Merely producing a valid E-number is insufficient. A statement such as 'the synchronizer changed' cannot cite a history row containing only a revision label as proof of the implementation change.

    Exercise and Expected Checks

    Write a five-line handover using only E1 and E2, as if the run stopped before history. Include scope, observation, requirement, unknown, and next human check. Then remove E2 and explain how your wording changes. Keep the reported checker mismatch distinct from a confirmed requirement violation. Do not request the assistant's full chain of thought; ask for source references and a short, reviewable explanation of the conclusion's limits.

    Check yourself Can a handover without E2 claim a violation of specification revision 3?

    No. It can report the mismatch recorded by the log, but must mark the applicable specification requirement as missing. An engineer should retrieve the approved excerpt before relating the observation to that requirement.

    Limits and Sources

    In-memory state disappears when the program exits; there is no checkpoint persistence, report file, or cross-session memory in this lab. A production retention policy would need separate approval and filtering before records are stored. The Python 3.12 copy module documents the copying mechanism used here. Copying a view provides application-level separation; it does not isolate untrusted executable code or validate the truth of its contents.

    Related topics

    • Up: Agent Design

    • Next: Handle Errors and Budgets

    Previous

    109 / 173

    Next: Handle Errors and Budgets

    Up next

    Up nextHandle Errors and Budgets

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Define the Task and Boundaries
    • Design the Architecture
    • Build Safe Read-Only Tools