Skip to content

iDB · Single source of truth for design state

iDB is the core of the iEDA.ai unified base—all tools and Agents share one in-memory design state. Not file handoff or IPC—direct read/write of DesignState in shared memory.

CORE CURRENT C++20
iDB
# shared-memory design state — single source of truth
[iDB] DesignState loaded for "aes_core" (sky130)
  cells: 125430  nets: 98420  layers: 11
[iDB] snapshot → snap_7f3a (2026-07-29T10:23:41)
  All tools read/write the SAME memory object
iMapsynthesisiFPfloorplaniPDNpoweriPLplacementiCTSclockiTOoptimizationiRTroutingiSTAtimingAiEDAdesign dataiPCLlayout modeliMapsynthesisiFPfloorplaniPDNpoweriPLplacementiCTSclockiTOoptimizationiRTroutingiSTAtimingAiEDAdesign dataiPCLlayout model

Core capabilities

Snapshot

Full design-state snapshot at any moment. Agents roll back to any snapshot when exploring optimization strategies and compare branch outcomes—snapshots anchor the Agent experiment loop.

Typed Delta

Structured difference between snapshots—not a raw diff but typed change records: which cells moved, nets rewired, timing paths affected. Agents use delta to understand precise change impact.

DirtySet

Tracks objects modified since last oracle verification. Incremental analysis scans only the dirty region, minimizing incremental compute cost.

CAS Commit

Compare-and-swap commit semantics. Multiple candidate plans cannot modify main head concurrently—CAS ensures one successful commit; others rebase to the latest snapshot and re-verify.

Stable ID

Stable object IDs across snapshots. Agents track the same cell/net across versions—position in snap_0001, move in snap_0007, timing slack in snap_0012.

Agent calling patterns

from ieda import AgentClient

client = AgentClient()
design = client.load_design("aes_core", tech="sky130")

# take a snapshot
snap = client.call("iDB.snapshot", design=design)
print(f"Snapshot: {snap.id}, cells={snap.cell_count}")

# compute delta between two snapshots
delta = client.call("iDB.delta", from_snap=snap1.id, to_snap=snap2.id)
print(f"Moved: {len(delta.moved_cells)}, New nets: {len(delta.new_nets)}")

# commit with CAS
result = client.call("iDB.commit",
    design=design,
    proposal=proposal,
    expected_head="snap_7f3a")
assert result.committed, "CAS failed — rebase required"

Input / output contract

SnapshotRequest → SnapshotRef

SnapshotRequest {
  design_ref: DesignRef        // Design reference
  label?: str                  // Optional snapshot label
}

SnapshotRef {
  id: str                      // Unique snapshot ID, e.g. "snap_7f3a"
  time: Timestamp              // ISO 8601 timestamp
  cell_count: int              // Cell count at snapshot
  net_count: int               // Net count at snapshot
  label?: str                  // Snapshot label
}

DeltaRequest → DesignDelta

DeltaRequest {
  from: SnapshotRef            // Source snapshot
  to: SnapshotRef              // Target snapshot
  scope?: DeltaScope           // Optional scope filter (CELL | NET | TIMING | ALL)
}

DesignDelta {
  moved_cells: []CellMove      // Moved cells
  new_nets: []NetChange        // New or changed nets
  timing_changes: []TimingDelta // Timing changes
  drc_changes: []DRCDelta      // DRC violation changes
}

CommitRequest (CAS) → CommitResult

CommitRequest {
  proposal_id: str             // Proposal identifier
  expected_head: str           // Expected head snapshot for CAS
  delta: DesignDelta           // Proposed change delta
}

CommitResult {
  committed: bool              // Whether CAS succeeded
  new_head?: str               // New head snapshot ID on success
  conflict_with?: str          // Conflicting head snapshot ID on failure
  reason?: str                 // Failure reason
}

Place in architecture

                    ┌──────────────────────────────────────┐
                    │              iDB                      │
                    │      (Unified design database—single source of truth)         │
                    │                                      │
                    │  ┌─────────┐  ┌──────────┐           │
                    │  │Snapshot │  │  Delta   │           │
                    │  │ Manager │  │  Engine  │           │
                    │  └─────────┘  └──────────┘           │
                    │  ┌─────────┐  ┌──────────┐           │
                    │  │DirtySet │  │   CAS    │           │
                    │  │ Tracker │  │  Service │           │
                    │  └─────────┘  └──────────┘           │
                    │  ┌─────────────────────────┐         │
                    │  │   Stable ID Registry    │         │
                    │  └─────────────────────────┘         │
                    └──┬───────┬───────┬───────┬──────────┘
                       │       │       │       │
              ┌────────┴──┐ ┌──┴───┐ ┌─┴─────┐ └───┬──────
              │   iPL     │ │ iRT  │ │ iSTA  │  ... │
              │ placement │ │route │ │timing │      │
              └───────────┘ └──────┘ └───────┘      │
                                             ┌──────┴──────┐
                                             │  Interface  │
                                             │ MCP/Py/Tcl  │
                                             └──────┬──────┘
                                                    │
                                              LLM Agent

Platform overview

See how the five unified-base modules work together.

Platform →

Interface

How Agents access iDB securely via the multi-protocol gateway.

Interface →

Evaluation

Quality gate for every change—a prerequisite for iDB commit.

Evaluation →