Vector FlowArchitecture

From Visual Flows toProduction-Grade Agents

Vector Flow is your visual layer. PAR is the execution engine. Every flow you draw becomes a live, stateful agent—no deploy step, no custom orchestration, and no glue code.

Open Vector Flow Learn About PAR

Always Live on PAR

Save → Instant Runtime

Every save in the builder updates the running agent. No manual deploy step.

Visual Design, Real State

Flows ↔ Durable Context

Variables, checkpoints, and logs are all backed by the PAR state layer.

Scales With You

Thousands of Flows

Flows are compiled to executions that can run in parallel across thousands of workers.

Flow → Runtime Mapping

Your Flow Design

┌───────────────┐
│  Recognition  │
│   (Is this    │
│  a refund?)   │
└───────┬───────┘
        │ yes
        ▼
┌───────────────┐
│  Parallel     │
│  Branch       │
└───────┬───────┘
   ▼          ▼
 API Call   Email

PAR Runtime Execution

┌──────────────────┐
│ Stateless Worker │
│  - Recognize     │
│  - Route Branch  │
└────────┬─────────┘
         │
         ▼
  ┌──────────────┐
  │  State Layer │
  │  - Variables │
  │  - Checkpoint│
  └──────────────┘

Visual flows compile down to an execution graph that PAR runs across stateless workers, with all state and checkpoints stored in the durable state layer.

Visual Builder on Top of a Managed Execution Layer

Vector Flow lets you think in terms of nodes, variables, and conversations. Behind the scenes, PAR takes care of concurrency, persistence, and recovery so those flows can run reliably at scale.

Execution Layer (you don’t build this)

• State persistence & automatic checkpointing

• Safe parallel execution with shared state

• Error recovery, retries, and backoff

• Scaling, load balancing, and worker pools

• Tracing, latency metrics, and observability

What You Actually Build

• Recognition patterns like "Is this a refund request?"

• Data flows: capture → enrich → respond

• Conditional logic and branching paths

• Integrations to your APIs, vaults, and tools

• Human-in-the-loop approvals and escalations

Real-Time Iteration

The Vector Flow builder has chat on the left and live logs on the right. Every change to a node is reflected on the very next request—no redeploy, no waiting.

This makes it natural to design flows by conversation: interact with your agent, inspect how nodes behave, then refine prompts and wiring in real time.

Flow, Node, and Variable Layers

At a high level, the system separates concerns into three layers:

• Flows: the overall graph of decisions and actions
• Nodes: individual reasoning, tools, or side effects
• Variables: the data that flows through and persists

PAR gives each execution its own state container so variables and checkpoints survive restarts and long-running processes.

Architecture That Scales from Toy Flows to Critical Systems

Vector Flow is used as the decision layer for everything from customer support to security platforms. The same architecture supports quick prototypes and mission-critical agents.

Latency & Throughput

• Recognition latency: p50 sub-400ms

• State operations: ~5,000 reads/sec

• Writes: ~1,000 writes/sec per project

Concurrency & Uptime

• 10,000+ concurrent flows per project

• Transparent scaling across workers

• 99.9%+ uptime with automatic failover

Real-World Usage

• Customer support automation at 50k+ chats

• Threat assessment in security platforms

• Long-running intake and triage workflows

Ready to see this architecture in action?

Start with a simple Start → Recognize → Respond flow, test it live in the builder, and know that every execution is backed by PAR from the very first request.

Build Your First Flow Read Full Vector Flow Docs