A runtime for composing task execution graphs across distributed, heterogeneous AI agents. Subtasks are routed by capability profile, context isolation is enforced at the session boundary, and validated outputs are synthesized through cross-agent consensus.
Every layer is designed around a single constraint: maximize effective throughput across heterogeneous inference capacity without sacrificing output quality.
Per-agent n-dimensional capability state is maintained and updated online using task outcomes, validator verdicts, and runtime telemetry. The router searches over a continuously-calibrated capability manifold with no static tags and no manual configuration.
(define (update-state c-a alpha task) (let ((r (task-outcome task)) (v (validator-verdict task)) (t (runtime-telemetry task))) (v+ (vscale (- 1 alpha) c-a) (vscale alpha (psi r v t)))))
Requests are decomposed into typed execution DAGs where each node carries I/O schema, QoS constraints, and privacy labels. The planner encodes both data dependencies and parallelizable branches, emitting a fully-typed graph consumed by the scheduler.
(define (make-dag vertices edges types qos) (list vertices edges types qos))
The scheduler retrieves candidates from the capability index in O(log n) time, then solves a constrained assignment over the bounded candidate set to minimize a weighted combination of latency, cost, and risk while satisfying capability thresholds and agent capacity limits.
(define (dispatch tasks agents) (letrec ((score (lambda (assignment) (+ (sum-lat assignment) (* lambda-c (sum-cost assignment)) (* lambda-r (sum-risk assignment))))) (feasible? (lambda (assignment) (and (covers-all? assignment tasks) (respects-capability? assignment) (respects-capacity? assignment))))) (argmin score (filter feasible? (candidate-assignments tasks agents)))))
Each agent receives the least-privilege context view its subtask requires. Windows are materialized by computing the dependency closure over the session graph, intersecting with per-agent policy filters and subtask schema. Cross-contamination is prevented without sacrificing coherence.
(define (context agent subtask) (redact (intersect (closure session-graph (ancestors subtask)) (policy agent) (schema subtask))))
Critical outputs are routed to an independent validator set. Semantic similarity detects divergence; final accept/reject is determined by a composite score over reference grounding, hard constraint checks, and executable validators. Resolution is by quorum, not majority vote.
(define (score output) (+ (* w-g (ground output R)) (* w-h (hardcheck output C)) (* w-e (exec output T)))) (define (accept? outputs) (>= (length (filter (lambda (o) (>= (score o) tau)) outputs)) quorum))
Validated outputs are normalized into a canonical typed intermediate representation, then folded deterministically in topological order along the original DAG. A final schema validator gates the output, ensuring structural correctness before delivery.
(define output (validate-schema (fold-topological (map normalize outputs) dag)))
Concrete outcomes made possible by coordinating heterogeneous inference at the infrastructure layer.
Workloads are routed to the minimum-effective-cost path satisfying SLO constraints, factoring in real-time capability state, latency, reliability, and unit cost. As frontier model pricing shifts, the scheduler adapts automatically.
Specialized agents for code generation, formal reasoning, and multimodal understanding can be composed into a single task workflow. No agent needs to be a generalist; each contributes its strongest capability class.
Agent failures trigger automatic subtask reassignment via ranked fallback candidates, checkpointed state, and idempotent replay semantics. Forward progress is maintained on SLA-bound tasks without side-effect duplication.
Minimal-sufficient context projection eliminates redundant token injection. Each agent processes only what its subtask requires, reducing per-request cost and enabling maximal parallelism across context-independent branches.
Every output is attached to an immutable lineage record spanning agent identity, capability snapshot, context slice, validator verdict, and synthesis path. This supports debugging, compliance review, and capability improvement feedback loops.
A canonical invocation envelope and adapter contract allows frontier APIs, local runtimes, fine-tuned models, and specialist executors to register as first-class agent nodes with no platform changes required.
Project Vercel was designed as research infrastructure. Lena AI became the first system to run on it, and a full commercial product followed.
Lena AI is an LLM-based assistant that complements deterministic language conversion pipelines, bridging paradigm-shift gaps that rule-based transforms cannot reach. It is the first system built on Project Vercel, using the orchestration runtime to route subtasks across heterogeneous inference backends and synthesize validated outputs.
The outcome validated the core thesis. A coordination runtime separating orchestration logic from model execution enables production-grade AI pipelines that are cost-adaptive, fault-tolerant, and auditable. Lena AI powered the development of Lena Code, a commercial M:N language conversion system now in active deployment.
Raw model capability has scaled dramatically. The dominant unsolved problem is orchestration under constraints. Open-ended tasks must be decomposed into subtasks that can be reliably matched to agents, executed in parallel, and synthesized into coherent outputs at production latency, without human review in the loop.
Project Vercel is our long-term research infrastructure for this problem. We study online capability state calibration, constrained placement under SLO objectives, minimal-sufficient context materialization, and reference-anchored validator quorum, working toward a general-purpose coordination runtime for heterogeneous AI systems.
Project Vercel is an independent research initiative. It is not affiliated with or endorsed by Vercel, Inc. The name reflects our alignment with the broader ethos of fast, composable, production-grade infrastructure. The system itself runs on Vercel-powered deployment primitives.
Project Vercel is an independent initiative by Studio Haze. It is not an official Vercel product, subsidiary, or regional branch.
The system is built around the Vercel deployment platform and benefits from its deployment model, delivery ergonomics, and operational simplicity.
The name reflects an affinity for the culture of fast iteration, clean deployment surfaces, and composable production systems. It signals admiration for that ecosystem, not formal affiliation.
Vercel is a trademark of Vercel, Inc. Project Vercel is an independent project and is not affiliated with, endorsed by, or sponsored by Vercel, Inc.
We're exploring partnerships with research institutions, AI infrastructure teams, and organizations running demanding multi-agent workloads. If this work is relevant to your stack, we'd like to hear from you. We're especially interested in teams building demanding AI systems on modern deployment platforms and composable infrastructure stacks.
contact@vercel.co.kr↗