Voss
Language

AI patterns as syntax.

Voss is a small AI-native language that compiles to readable Python. The core move is turning recurring AI workflow code into explicit constructs the compiler and runtime can reason about.

use voss_runtime::judge

fn triage(text: string) -> string {
    let route = {
        "type": "choice",
        "instructions": "Which queue handles this?",
        "criteria": {"billing": "Payment or refund.", "other": "Anything else."}
    }
    let res = judge(text, {"route": route})
    let p: probable<string> = res.answers["route"].to_probable()

    if p @ p >= 0.80 {
        return p.value
    } else {
        return "unknown"
    }
}

Recent direction

More workflow, less ceremony.

The language track is tightening the parts of agent work that usually leak into prompts: where confidence comes from, what a judgment costs, and how failure behaves.

No made-up confidence

Every probable value says whether its number came from Jev, the model's own report, or your code. Unknown never passes a gate, and the compiler warns (ANLY004) when a gate can never pass.

Judgments are a runtime call

`judge()` asks Jev a bounded question and returns answers you can turn into probable values. Each call's spend and receipt are recorded on the run and shown in `voss audit`.

Failure paths are explicit

Retries, fail-fast gathers, budget fallbacks, and bounded review loops are part of the workflow model instead of hidden control flow.

Runtime constructs

Inside one agent.

The pieces Voss treats as first-class instead of framework convention — confidence, context, routing, budget, and concurrency.

probable<T>

Confidence belongs in the type system

Probable values record where their confidence came from. A plain `ask()` reply is unmeasured, so a gate on it never passes; `judge(...).to_probable()` gives a measured probability to gate on.

ctx

Prompt windows are scoped resources

Context blocks define token budgets, inputs, compression, and eviction as part of the program structure.

match similar

Semantic routing is declarative

Route by meaning with embedding indexes prepared ahead of runtime, not by sprinkling ad hoc similarity calls through handlers.

within budget

Cost limits are control flow

Budgets and fallbacks are explicit language constructs, so overruns have a designed path instead of a surprise bill.

spawn / gather

Agents compose like concurrent tasks

Parallel agent work, timeouts, and fallbacks are written directly, with the runtime owning lifecycle and coordination.

Coordination spec

Across a whole team.

The same language scales up from one agent to an engineering organization. Roles, principles, gates, and memory become declared, compiler-checked coordination — so a team run is shorter and clearer than the equivalent Python.

principles { }

Engineering culture as config

Declare the principles every agent inherits — smallest diff, no claim without evidence, stay in scope. They compile to immutable config and are recorded in the audit.

team "name" { }

The roster is the source of truth

Roles, scope, budget, tools, and model tier compile to a frozen team config. The EM can only dispatch to declared roles, and scope can never widen past the ceiling.

gate done { }

Completion has requirements

A done gate names what must hold before a card ships: tests passed, independent review, evidence references. Agents can't mark their own work done.

memory { }

Institutional knowledge has a home

Point decisions, sessions, and semantic memory at durable paths so context — and the session tree — survives across runs.

gate done {
  require tests_passed
  require independent_review
  require evidence_refs
}

memory {
  decisions: ".voss/decisions"
  sessions:  ".voss/sessions"
  semantic:  ".voss-cache/semantic"
}