The Borz language

Two first-class constructs. One .borz source file.

Declare pure LLM agents with a model, persona, and typed interface. Write actors that compile to four targets — native binary, DEMIX microservice, DENSE nanoservice, or Ephernity contract — without changing the program. Both constructs share one typed message bus.

classifier.borz spec v0.9.5

import "std/string" as *

msg Classify:
    text: str

actor Classifier:
    @persistent var label:      str = "unknown"
    @persistent var call_count: i64 = 0

    on msg Classify:
        call_count = call_count + 1
        infer:
            system: "Classify the topic in one word."
            user:   msg.text
            target: label
        response(label, f"[{call_count}] {to_upper(label)}")

Read the spec Open the playground → Run a Clan →

compile targets

~50µs

p50 dispatch · no-op handler

13+

verified examples

Two building blocks

One language. Two kinds.

agent and actor are distinct first-class constructs in the same .borz source file. The compiler checks both sides of every handoff between them.

agent

pure LLM agent

Claude · ollama · gemma4

A first-class Borz construct defining a pure LLM persona: persona prose, a mandated model and host, a declared toolset, memory, and a typed message interface. The whole agent is inference — it does not call an LLM, it runs as one.

→Model-portable: pin to claude:opus, local:ollama:gemma4:12b, or any compliant host
→Typed interface: declares which message types it handles; compiler rejects wrong-shape callers
→Memory: rolling-window or persistent conversation — declared in source, managed by Clan Control
→Tools: declared capabilities the Clan enforces as policy caps at dispatch time

Never DENSE

Agents have no handler bodies and no state variables. The compiled artifact is a validated JSON manifest. DENSE constraints do not apply.

Agent construct — full reference →

actor

deterministic compiled code

DENSE · DEMIX · native · Ephernity

Isolated compiled Borz code with typed messages, sequential handlers, and persistent state. The compiler enforces isolation — no shared variables, no global state. May call infer for one typed LLM step (agentic actor) — still an actor, still deterministic core.

→Write once: same source compiles to all four targets — change the flag, not the program
→@persistent state: survives restarts and hot-reloads; DENSE snapshot on each dispatch
→DENSE target: flat ELF, ~50 µs p50 dispatch (single no-op handler benchmark), 2 MiB cap, Ed25519 receipt per call
→Ephernity target: deterministic smart contract on the Epher Compute Chain

Agentic actor ≠ agent

An actor that calls infer is an agentic actor. Its control logic is still Borz source code. It is not a pure LLM agent.

Actor construct — full reference →

One typed message bus

Agents and actors communicate over the same typed message system. An actor sends a typed message to an agent — the agent processes it as an LLM call and sends a typed reply back. The compiler checks both sides of every contract at build time.

RiskActor (DENSE) → NarrateAnomaly → AnomalyNarrator (gemma4) → AnomalyReport → AuditActor (DENSE)

Actor compile targets

Write once. Run four ways.

The same actor source compiles to a standalone binary, a supervised microservice, a sub-millisecond nanoservice on bare KVM, or a smart contract on the Epher Compute Chain — without changing the program.

The runtime underneath

DELIGHT — Decent Edge Lightweight Application Server

The platform Borz programs run on in production, with two execution lanes: DEMIX for full microservice VMs and DENSE for bare-metal nanoservices. The compiler emits artefacts DELIGHT knows how to schedule, supervise, and hot-reload.

--target native

Native binary

Single static binary · zero runtime dependencies

Compiles to one self-contained Go binary today; MLIR/LLVM lowering planned
Built-in CLI and HTTP server — no external runtime needed
State auto-persisted as JSON; infer calls any LLM provider
Ideal for local tools, CI workers, and serverless functions

--target demix

Microservice — DEMIX

Full Linux VM · supervised lifecycle · hardware isolation

DEMIX is Decent Edge's microservice VMM — each actor runs in its own Linux micro-VM
Millisecond cold starts; full network stack; hardware-isolated; supervised restart on failure
Rolling hot-reload via `borz deploy` without dropping connections
Choose when you need a full runtime, POSIX APIs, or unbounded in-memory state

--target dense

Nanoservice — DENSE

No OS · no runtime · KVM directly · sub-millisecond

DENSE is Decent Edge's nanoservice layer — each handler is a flat binary on bare KVM
~50 µs p50 dispatch (single no-op handler benchmark); 16 KB binary size; 2 MiB memory cap enforced at compile time
Comparable to Microsoft Hyperlight — with a high-level actor language on top
Distributed state replication built in; primary/follower failover with zero downtime

--target ephernity

roadmap

Smart contract — Ephernity

Deterministic actor on Epher Compute Chain · attested · auditable

Actors with @deterministic and @canonical decorators compile to Epher Compute Chain contracts
Every execution is attested via HATP (Hardware Attestation Trust Protocol) signing — tamper-evident, append-only audit trail
Actor state is an immutable append-only ledger — write logic once, the chain enforces invariants
BLAKE3 + Falcon-1024 signing; spans T0 (seconds) to T7 (eternal) timed-ledger tiers

Examples

Real programs, real short.

Each tab compiles to all targets without changes. examples/ contains the full corpus and forms the test suite.

counter.borz The hello-world of actors: state + handler.

msg Increment:
    by: i64

actor Counter:
    @persistent var count: i64 = 0

    on msg Increment:
        count = count + msg.by
        response(count)

structs___traits.borz Plain data types, trait contracts, local bindings.

type Rect:
    w: i64
    h: i64

msg Inscribe:
    w: i64
    h: i64

trait Shape:
    fn area(self) -> i64

actor Inscriber:
    @persistent var current_w: i64 = 0
    @persistent var current_h: i64 = 0

    on msg Inscribe:
        let r = Rect(msg.w, msg.h)
        current_w = r.w
        current_h = r.h
        response(area=current_w * current_h)

impl Shape for Inscriber:
    fn area(self) -> i64:
        ret current_w * current_h

f_strings___imports.borz String interpolation and stdlib imports (RFC-0022/0023).

import "std/string" as *
import "std/time"   as *

msg Greet:
    name: str

actor Greeter:
    @persistent var greet_count: i64 = 0

    @http(path="/greet")
    on msg Greet:
        greet_count = greet_count + 1
        let ts      = unix_now()
        let up      = to_upper(msg.name)
        let message = f"Hello, {up}! Served {greet_count} times. t={ts}"
        response(message)

map_state.borz Map[K,V] persistent state with subscript access (RFC-0020).

msg SetScore:
    player: str
    score:  i64

msg GetScore:
    player: str

actor Scoreboard:
    @persistent var scores: Map[str, i64] = {}

    @http(method="POST", path="/score")
    on msg SetScore:
        scores[msg.player] = msg.score
        response(ok=1)

    @http(path="/score")
    on msg GetScore:
        let player = msg.player
        let score  = scores[player]
        response(player, score)

list_ops.borz Push / pop / len / clear / index on persistent lists (RFC-0019).

msg Push:
    value: i64

msg Pop: {}

msg Peek: {}

actor Stack:
    @persistent var items: List[i64] = []

    on msg Push:
        items.push(msg.value)
        response(items.len())

    on msg Pop:
        let value = items[items.len() - 1]
        items.pop()
        response(value)

    on msg Peek:
        response(items.len())

llm_in____lines.borz infer: makes one typed LLM call inside an actor handler — the agentic actor pattern.

msg Classify:
    text: str

actor Classifier:
    @persistent var label: str = "unknown"

    @cli(command="ask", desc="Classify input")
    on msg Classify:
        infer:
            system: "Classify the topic in one word."
            user:   msg.text
            target: label
        response(label)

response_styles.borz Six response() syntax patterns — reference guide, not all handlers belong in one actor.

msg Compute:
    a: i64
    b: i64

actor Calculator:
    @persistent var calls: i64 = 0
    @persistent var items: List[i64] = []

    // Style 1: explicit — field name written out
    on msg Compute:
        response(total=msg.a + msg.b)

    // Style 2: shorthand — local var name becomes field name
    on msg Compute:
        let total = msg.a + msg.b
        response(total)              // → {total: ...}

    // Style 3: method call — last identifier inferred
    on msg Compute:
        items.push(msg.a)
        response(items.len())        // → {len: ...}

    // Style 4: member access — member name inferred
    on msg Compute:
        response(msg.a)              // → {a: ...}

    // Style 5: bare expression — single field gets "value"
    on msg Compute:
        calls = calls + 1
        response(msg.a + msg.b)      // → {value: ...}

    // Style 6: multiple bare — positional "value_N"
    on msg Compute:
        calls = calls + 1
        response(msg.a + msg.b, msg.a * msg.b, calls)
        // → {value_0: ..., value_1: ..., calls: ...}

bank__http_.borz Decorator-driven REST in a single file.

msg Transfer:
    from_id: i64
    to_id:   i64
    amount:  i64

actor Bank:
    @persistent var a1: i64 = 100
    @persistent var a2: i64 = 100

    @http(method="POST", path="/transfer")
    on msg Transfer:
        if msg.from_id == 1:
            if a1 < msg.amount:
                fail(code=402, msg="insufficient")
            a1 = a1 - msg.amount
            a2 = a2 + msg.amount
        response(a1, a2)

bytes_round_trip.borz RFC-BORZ-EXT-001 — variable-length binary, hex round-trip.

import "std/bytes" as *

msg Roundtrip:
    input: str

actor Echo:
    @persistent var last_hex: str = ""
    @persistent var last_len: u64 = 0

    @http(method="POST", path="/roundtrip")
    on msg Roundtrip:
        let raw = bytes_from_hex(msg.input)
        let n   = len_b(raw)
        let hex = to_hex_b(raw)
        last_hex = hex
        last_len = n
        response(hex=hex, length=n)

bytes___decimal___time.borz RFC-BORZ-EXT-001/005/006 — bytes, Decimal rounding, wall_now_ms.

import "std/bytes"  as *
import "std/bignum" as *
import "std/time"   as *

msg Check:
    hex: str

actor Smoke:
    @persistent var calls: i64 = 0

    @http(method="POST", path="/check")
    on msg Check:
        let raw = bytes_from_hex(msg.hex)
        let n   = len_b(raw)
        let now = wall_now_ms()
        let mul = decimal_mul(decimal_from_str("12.34"),
                              decimal_from_str("0.05"))
        let eur = decimal_round(mul, 2, "half_even")   # "0.62"
        calls = calls + 1
        response(bytes_len=n, eur=eur, now=now, calls=calls)

Getting started

60 seconds from intent to artefact.

Borz is a closed-source product of Decent Edge. There is no public source repository, no toolchain to install. The first-touch path is the remote compilation API: submit your Borz program, receive an artefact in seconds. The same API powers the in-browser playground.

Try the playground (no signup)

# Open in your browser:
https://play.borz.ai

# Or hit the public anonymous endpoint:
curl -F target=native \
     -F source=@hello.borz \
     https://api.borz.ai/v1/compile

Write a Borz program

msg Hello:
    name: str

actor Greeter:
    on msg Hello:
        response(reply="hi, " + msg.name)

Request an API key for production

# Sign up at decentedge.com/borz
# You receive a per-tenant key.
export BORZ_API_KEY=de_live_…

Compile to your target backend

curl -H "Authorization: Bearer $BORZ_API_KEY" \
     -F target=dense \
     -F source=@hello.borz \
     -o hello.tar.gz \
     https://api.borz.ai/v1/compile

# The tarball ships ELF nanobinaries
# ready to deploy on a DEMIX or DENSE host.

Enterprise option

For air-gapped or latency-sensitive workflows we ship an offline CLI as a signed, hardware-bound binary under a Decent Edge commercial license. The CLI compiles locally without phoning home. Contact decentedge.com to request access.

Open the playground Language spec Request enterprise access

What comes next

Write actors. Build a Clan.

Borz actors are the code-driven members of a Borz Clan — running alongside AI agents on one unified substrate. Once you write actors in Borz, you can deploy them directly into a Clan via Clan Control.

Clan Control → Actor construct →