Archify Diagram Types: 5 Technical Diagrams Supported by the AI Generator

Archify supports five distinct diagram types—Architecture, Workflow, Sequence, Data Flow, and Lifecycle—each backed by dedicated JSON schemas for type-safe validation and rendering.

Archify is an open-source diagram generation tool from the tt-a1i/archify repository that transforms structured JSON input into self-contained HTML/SVG visualizations. Understanding the diagram types supported by Archify helps developers choose the right visualization for system documentation, API design, and process modeling.

The Five Diagram Types Supported by Archify

The project defines five specialized diagram formats in archify/schemas/, each optimized for specific technical communication needs.

Architecture Diagrams

Architecture diagrams visualize high-level system components including cloud resources, databases, caches, services, and security boundaries. These are ideal for infrastructure overviews and deployment documentation.

The structure is governed by archify/schemas/architecture.schema.json, which validates components like nodes, connections, and security groups before rendering.

Example prompt:

Use archify to draw an architecture diagram:
React frontend calls a Node.js API backed by PostgreSQL and Redis, deployed on AWS behind CloudFront.

Workflow Diagrams

Workflow diagrams map request lifecycles, approval flows, CI/CD pipelines, and agent tool chains. These charts emphasize step order and decision branches rather than temporal sequences.

Validation occurs against archify/schemas/workflow.schema.json, ensuring proper node connections and state transitions.

Example prompt:

Use archify to draw a workflow:
User submits a request → Agent plans → Approval gate (if needed) → Tool call → Trace log → Final reply.

Sequence Diagrams

Sequence diagrams illustrate API call chains, async traces, cache fallback patterns, and service interactions with strict temporal ordering. These focus on "who calls whom" and response flows.

The schema at archify/schemas/sequence.schema.json enforces participant definitions and message ordering.

Example prompt:

Use archify to draw a sequence diagram:
User opens a page, the frontend calls the API, the API verifies JWT, reads Redis, falls back to PostgreSQL on cache miss, returns JSON, and emits trace.

Data Flow Diagrams

Data flow diagrams track pipelines, ETL/ELT processes, analytics events, PII isolation boundaries, and warehouse synchronization. These visualize how data moves through systems with sensitivity classifications.

Schema validation happens via archify/schemas/dataflow.schema.json.

Example prompt:

Use archify to draw a data flow:
Web and mobile emit analytics events → Edge API collects them → Consent gate filters PII → Kafka carries accepted events → Warehouse stores analytics tables → Feature store derives daily features → Dashboards and ML model consume downstream data.

Lifecycle Diagrams

Lifecycle diagrams model state machines for orders, tasks, deployments, or agent runs, including wait states, retry paths, and terminal conditions. These visualize state transitions rather than linear flows.

The schema at archify/schemas/lifecycle.schema.json validates state definitions, transition events, and terminal outcomes.

Example prompt:

Use archify to draw a lifecycle diagram:
Agent run starts at Queued, moves through Planning, Executing, and Reviewing. It can pause at Needs Approval, wait at Blocked, retry after Failed, end at Cancelled or Expired, or finish at Completed.

Schema Validation and Type Safety

Each diagram type supported by Archify uses a dedicated JSON schema to enforce structure before rendering. Located in archify/schemas/, these files prevent invalid intermediate representations from reaching the rendering engine:

• Architecture: architecture.schema.json
• Workflow: workflow.schema.json
• Sequence: sequence.schema.json
• Data Flow: dataflow.schema.json
• Lifecycle: lifecycle.schema.json

This schema-first approach ensures that the CLI tool at bin/archify.mjs can validate inputs early and provide clear error messages when diagram structure violates type constraints.

Generating Diagrams via CLI

You can generate any of the five diagram types using the Archify CLI. First install the skill:

npx skills add tt-a1i/archify -g

Then render specific diagram types:

node bin/archify.mjs render workflow examples/agent-tool-call.workflow.json workflow.html

The repository includes working examples for each diagram type:

• Architecture: examples/web-app.html
• Workflow: examples/workflow-agent-tool-call-rendered.html
• Sequence: examples/sequence-cache-miss-request.html
• Data Flow: examples/dataflow-product-analytics.html
• Lifecycle: examples/lifecycle-agent-run.html

Summary

• Archify supports five diagram types: Architecture, Workflow, Sequence, Data Flow, and Lifecycle diagrams.
• Each diagram type has a dedicated JSON schema in archify/schemas/ for input validation.
• Architecture diagrams show system components and cloud infrastructure.
• Workflow diagrams depict approval flows and CI/CD pipelines.
• Sequence diagrams trace API calls and service interactions chronologically.
• Data Flow diagrams map ETL pipelines and data sensitivity boundaries.
• Lifecycle diagrams model state machines with retry and terminal states.

Frequently Asked Questions

What file format does Archify use for diagram definitions?

Archify uses JSON Intermediate Representation (IR) files validated against type-specific schemas. Each diagram type requires a JSON file matching the structure defined in its corresponding schema file in archify/schemas/.

Can I use Archify without installing it globally?

Yes. You can use npx to run Archify without permanent installation: npx skills add tt-a1i/archify -g installs the skill temporarily, or you can invoke the CLI directly via node bin/archify.mjs after cloning the repository.

Which diagram type should I use for showing API authentication flows?

Use Sequence diagrams for API authentication flows. According to the sequence.schema.json specification, these diagrams excel at showing "who calls whom, in what order, and what returns"—perfect for JWT verification, cache lookups, and fallback chains.

Where can I find example implementations of each diagram type?

Working examples for all five diagram types reside in the examples/ directory. Key files include web-app.html (Architecture), sequence-cache-miss-request.html (Sequence), and lifecycle-agent-run.html (Lifecycle), demonstrating valid JSON IR structures for each type.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}