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 selects over this online capability model 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 an indexed capability store, then applies a constrained assignment over the bounded candidate set, balancing 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 reduced while preserving the dependency context needed for coherent execution.
(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 uses validator quorum rules rather than a simple 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 through a deterministic synthesis path 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)))
Formula snippets use Lispex, a Scheme-like internal notation for Project Vercel orchestration logic.
Concrete outcomes made possible by coordinating heterogeneous inference at the infrastructure layer.
Workloads are routed by a cost-aware policy that respects 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.
STUDIO HAZE built Lena Code with Project Vercel orchestrating the AI agents that wrote it — its deterministic engine, CSKernel™, most of all. Project Vercel is the development engine behind the codebase, not a runtime inside the product; Lena Code, a 30-language conversion platform in active deployment, runs on its own stack.
Lena Code converts source code across 30 programming languages. Its core engine, CSKernel™, performs deterministic compilation across the full conversion surface, driven by Lispex as its surface language. Lena AI extends that surface where deterministic transforms reach paradigm-shift gaps no rule set can express, synthesizing the bridge with precision and accountability.
CSKernel™ holds the deterministic core and Lena AI covers the gaps no rule set can express — a deterministic-first pipeline with model-assisted handling only where it is needed: cost-adaptive, fault-tolerant, and auditable.
Topaz is a small, closed language for application intent. It reads like Python or TypeScript and compiles to a self-contained native binary. It is a shipped, open-source compiler developed by people and AI agents under adversarial dialectic review. STUDIO HAZE used the Project Vercel research workflow to coordinate that adversarial agent review — the same cross-agent discipline the engine is built around, applied in the field.
function greet(name: string, language: string) -> string { return match language { case "한국어" => "안녕하세요, {name}님!" case "Русский" => "Привет, {name}!" case _ => "Hello, {name}!" } } let 사용자 = "김토파즈" print(greet(사용자, "한국어"))
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 requiring manual review on every subtask.
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↗