A runtime that composes task execution graphs across heterogeneous AI agents. It routes each subtask to whatever agent is currently best at it. Sessions never share context. An output ships only after other agents fail to break it.
Every layer answers one constraint. Get the most out of heterogeneous inference capacity without letting quality slip.
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. A composite score over reference grounding, hard constraint checks, and executable validators decides accept or reject. 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 before delivery.
(define output (validate-schema (fold-topological (map normalize outputs) dag)))
Formula snippets are written in Lispex, the deterministic Lisp from the same studio. It runs at lispex.com.
Concrete outcomes made possible by coordinating heterogeneous inference at the infrastructure layer.
Workloads are routed by a cost-aware policy under SLO constraints. When frontier model pricing shifts, the scheduler follows without manual retuning.
Specialized agents for code, formal reasoning, and multimodal work compose into a single task workflow. No agent has to be a generalist. Each contributes the thing it is best at.
Agent failures trigger reassignment through ranked fallbacks, checkpointed state, and idempotent replay. SLA-bound tasks keep moving without duplicated side effects.
Each agent gets only what its subtask needs. That keeps per-request cost down and lets context-independent branches run wide.
Every output carries an immutable lineage record, from agent identity and context slice to validator verdict and synthesis path. Debugging and review start from the record, not from memory.
A canonical invocation envelope lets frontier APIs, local runtimes, fine-tuned models, and specialist executors register as first-class agent nodes. No platform changes required.
Project Vercel is research infrastructure from STUDIO HAZE, the studio behind Lena Code. The runtime is shaped by what production actually demands. Isolation that holds under deadline. Validation that does not slow the pipeline. Records that survive an audit. Lena Code itself is a separate commercial product and runs on its own proprietary engine.
Lena Code converts source code across languages while keeping its meaning fixed. The proprietary Lena Engine does the deterministic work, rule first. Lena AI steps in where paradigm gaps exceed what any rule set can express.
The Lena Engine holds the deterministic core. Lena AI covers what rules cannot express. The pipeline stays deterministic first, with model help only where it earns its place.
Topaz is a small, closed language for application intent. It reads like Python or TypeScript and compiles to a self-contained native binary with zero crates.io dependencies. STUDIO HAZE ships it at topaz.ooo, versioned and release-signed.
function greet(name: string, language: string) -> string { return match language { case "한국어" => "안녕하세요, {name}님!" case "Русский" => "Привет, {name}!" case _ => "Hello, {name}!" } } let 사용자 = "김토파즈" print(greet(사용자, "한국어"))
Selected traces from internal runs. Workload names and identifiers are removed. What remains is the shape of the coordination. Review rounds, passing checks, and the differential fixtures behind each merged change.
A standard-library bridge landed with lazy evaluation and argument order matched to the reference interpreter, case by case.
Suggestion diagnostics for unresolved names. Review caught five position-correctness gaps before merge.
An over-reaching static analysis was rejected in review and reshaped into a sound direct-only rule.
Type-alias resolution in typed guards. A suspected soundness hole was investigated and closed with a paired differential fixture.
Unknown members on closed union arms are now rejected through one shared predicate.
Multi-module native output pinned against the reference interpreter with a dedicated differential harness.
Raw model capability has scaled dramatically. The dominant unsolved problem is orchestration under constraints. An open-ended task has to break into subtasks an agent can actually be matched to. The pieces run in parallel and come back together at production latency, and no one can afford a manual review on every piece.
Project Vercel is our long-term research infrastructure for this problem. We study online capability calibration, constrained placement under SLO objectives, minimal-sufficient context materialization, and reference-anchored validator quorum. The long-term target is 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 is an homage to a way of shipping software we admire. 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 talk with research groups and infrastructure teams that run serious multi-agent workloads. If this work overlaps with yours, write to us.
contact@vercel.co.kr↗