use cases

Zindex is a stateful diagram runtime for AI agents. Diagrams are generated from data, evolve incrementally over time, and are validated against semantic rules - not just rendered once and forgotten.

Why agents need a diagram runtime

Static diagram generators produce one-shot output. Zindex provides durable scene state with revision history, incremental operations, and semantic validation. This unlocks use cases that rendering-only tools can't touch:

01

Diagrams from data

Agents create diagrams programmatically from codebases, APIs, infrastructure, and research - not by hand.

02

Incremental evolution

Apply typed operations (createNode, createEdge, moveElement) to patch diagrams. No regeneration for small changes.

03

Revision history

Every mutation creates an immutable revision. Diff any two revisions to see exactly what changed.

04

Semantic validation

40+ rules catch errors before rendering. Family-specific validation for workflow, ER, sequence, and org chart diagrams.

How teams use zindex

architecture

Living architecture documentation

An agent monitors a codebase via git hooks or CI and maintains an always-current architecture diagram as a persisted scene. On each PR, it scans for new services, endpoints, and database tables, then applies incremental ops to the existing diagram. Reviewers diff revision N vs N-1 to see exactly what changed architecturally.

The agent patches the diagram - it doesn't regenerate it. Revision history shows architectural evolution over time.
ER diagrams

Database schema visualization from migrations

On every commit that touches database migrations (Prisma, Drizzle, Alembic), a CI step parses migration files and creates or updates an ER diagram with compartmented entity boxes showing columns, types, PK/FK badges, and crow's-foot cardinality from foreign key definitions.

Compartmented entities with typed columns, cardinality markers, and identifying/non-identifying relationship styling make the output genuinely useful - not a box-and-line approximation.
incident response

Incident topology and timeline

During an incident, an agent generates a focused topology diagram showing affected services and their connections. As the incident evolves, it applies ops to update status - each update creates a new revision. The incident timeline is captured in diagram revisions: "here's what the topology looked like when the DB went down vs after the failover."

Revision history creates an automatic incident timeline. Each revision is a snapshot of system state at a point in time.
business strategy

Lean canvas and business model generation

An agent researches a company or product idea, then creates a structured lean canvas using frames for the 9 sections (Problem, Solution, Key Metrics, Unique Value Prop, etc.). It populates each section with research findings and uses constraints for automatic layout. The canvas evolves as the agent learns more.

Constraints and frames make layout automatic. The agent describes content semantically - the engine handles positioning. Revision history tracks how the business model evolved.
agent systems

Agent workflow visualization

When building multi-agent systems, an orchestration agent creates a BPMN-style workflow diagram showing each agent's role, tools, and data flow. As agents are added or removed, ops update the diagram. Validation ensures the workflow is structurally sound. The diagram serves as both documentation and a runtime artifact.

Workflow family rendering with swimlanes, gateway shapes, and semantic validation makes this a natural fit. The diagram isn't just documentation - it's a structured representation of the agent system.
API mapping

API dependency mapping

An agent scans OpenAPI specs across microservices and creates a service topology diagram with edges representing API calls. Labels show endpoint paths and HTTP methods. Auto-layout arranges services hierarchically. On each deploy, the agent updates the diagram with new or removed endpoints.

Auto-layout, semantic validation, and incremental updates keep the diagram current without manual maintenance.
compliance

Compliance and audit trail diagrams

For regulated industries, an agent generates data flow diagrams showing where PII moves through the system. Edges are labeled with data types. Revision history provides an audit trail - "at this date, this is what the data flow looked like." Validation rules enforce compliance patterns.

Revision history as audit trail plus custom validation rules. The protocol's structure directly serves regulatory needs.
org charts

Organizational structure from HR data

An agent reads HR system data and generates structured person cards with name, title, department color accent, and avatar icons. Hierarchical auto-layout positions the tree. Solid edges for direct reports, dashed for matrix relationships. The chart updates automatically as the org changes.

Org chart cards with accent stripes, PK/FK-style structured rendering, and auto-layout make the output professional-grade without manual positioning.
onboarding

Progressive onboarding diagrams

When a new engineer joins, an agent reads the codebase and generates a progressive series of architecture diagrams - starting simple (high-level services) and adding detail (databases, queues, caches). Each diagram is a revision of the same scene, so the engineer steps through complexity levels.

Revision history as progressive disclosure. The agent builds up complexity incrementally using ops, and each revision is a learning step.
design review

Visual architecture diffs in PRs

In a PR that changes system architecture, an agent generates a before/after diagram pair using scene diffing. Added nodes in green, removed in red, modified edges in yellow. Posted as a PR comment, reviewers see the architectural impact at a glance.

Scene diffing computed from structured data - not pixel comparison. The visual diff is precise and meaningful.

Get started

Zindex works with any AI agent via MCP or HTTP API.