See Borz in action.

// showcase/06_pure_agent/review.borz
// The corrected agent/actor model — a pure LLM agent and a deterministic actor
// talking over one typed message bus.

msg ReviewResult:
    verdict: str
    score:   i64

// Deterministic actor — compiles to DENSE; replayable; Ed25519 receipt per call.
actor ReviewLog:
    @persistent var reviewed: i64 = 0
    @persistent var flagged:  i64 = 0

    on msg ReviewResult:
        reviewed = reviewed + 1
        if msg.score < 50:
            flagged = flagged + 1

// Pure LLM agent — host-bound (Claude); never DENSE.
// Compiled artifact: reviewcoder.agent.json (JSON manifest, not a binary).
agent ReviewCoder:
    kind:    coder
    persona: "Senior code reviewer. Terse; cites file:line; never speculative."
    model:   claude:opus                 # mandated host:model
    memory:  conversation                # uses prior turns
    budget:  <= 200k tokens / hour
    tools:   [ ReviewLog.ReviewResult ]  # agent→actor: record a finished review
    accepts: [ prompt ]                  # generalist: accepts arbitrary prompts
    emits:   [ ReviewResult ]            # typed output consumed by ReviewLog

// Agent defined for local Gemma4 via ollama.
// model: local:ollama:gemma4:12b — pinned to the local host.
// No ANTHROPIC_API_KEY needed. No cloud cost.

msg SummariseDoc:
    title:   str
    content: str

agent LocalSummariser:
    kind:    summariser
    model:   local:ollama:gemma4:12b
    memory:  rolling(turns: 3)

    system: """
        You summarise technical documents.
        Return a 3-bullet executive summary.
        Be precise; avoid hedging language.
    """

    tools:   [ DocStore.SaveSummary ]
    accepts: [ SummariseDoc, prompt ]
    emits:   [ Summary ]

// examples/20_llm_classifier/classifier.borz
// Agentic actor — uses infer to call a model; still an actor, still DENSE-eligible.

msg Classify:
    text: str

actor Classifier:
    @persistent var last_label: str = ""
    @persistent var call_count: i64 = 0
    @persistent var pos_count:  i64 = 0
    @persistent var neg_count:  i64 = 0

    @http(method="POST", path="/classify")
    @cli(command="classify", desc="Classify text sentiment")
    on msg Classify:
        infer:
            system: "Classify sentiment. Reply: POSITIVE, NEGATIVE, or NEUTRAL."
            user:   msg.text
            target: last_label
        call_count = call_count + 1
        if last_label == "POSITIVE":
            pos_count = pos_count + 1
        if last_label == "NEGATIVE":
            neg_count = neg_count + 1
        response(last_label, pos=pos_count, neg=neg_count, total=call_count)

// examples/35_ollama_chat/chat.borz
// Multi-turn conversational actor using Ollama + any local model.
// Set BORZ_LLM_MODEL=gemma4:12b to run on Gemma 4 locally.

msg Chat:
    message: str

actor ChatBot:
    @persistent var turn_count: i64 = 0
    @persistent var u0: str = ""
    @persistent var u1: str = ""
    @persistent var u2: str = ""
    @persistent var a0: str = ""
    @persistent var a1: str = ""
    @persistent var a2: str = ""

    @http(method="POST", path="/chat")
    on msg Chat:
        if str_len(msg.message) == 0:
            fail(code=400, msg="message required")
        // Build context from last 3 exchanges
        let ctx = ""
        call go """
            // (sliding-window history built from u0..u2, a0..a2)
        """
        let response = ""
        infer:
            system: "You are a helpful assistant. Respond concisely."
            user:   ctx
            target: response
        // Rotate history
        u0 = u1
        a0 = a1
        u1 = u2
        a1 = a2
        u2 = msg.message
        a2 = response
        turn_count = turn_count + 1
        response(reply=response, turns=turn_count)

// examples/40_model_arena/arena.borz
// Side-by-side model comparison — primary model (env) vs secondary (POST field).
// Run with gemma4:12b as primary and gemma4:27b as secondary.

msg Compare:
    prompt:  str
    model_b: str   # e.g. "gemma4:27b"

actor Arena:
    @persistent var battle_count: i64 = 0

    @http(method="POST", path="/compare")
    on msg Compare:
        let response_a = ""
        // Primary model via BORZ_LLM_PROVIDER / BORZ_LLM_MODEL env
        infer:
            system: "Be concise and direct."
            user:   msg.prompt
            target: response_a
        // Secondary model via raw Ollama API call (call go block)
        let response_b = ""
        call go """
            // POST to http://localhost:11434/api/chat with msg.ModelB
        """
        battle_count = battle_count + 1
        // Return two-column comparison card as HTML
        serve(content_type="text/html", body=_html)

// showcase/07_qa_reviewer/qa.borz
// Three-tool quality-assurance agent on Claude.
// Issue / Pass / Escalation are separate message types → separate tools.
// The actor records the full audit log deterministically; the agent never touches DENSE.

msg Issue:
    rule:     str
    severity: str    // "error" | "warning"
    excerpt:  str

msg Pass:
    rule: str

msg Escalation:
    reason: str

// QA audit log — deterministic system of record. DENSE-eligible.
actor QALog:
    @persistent var errors:      i64 = 0
    @persistent var warnings:    i64 = 0
    @persistent var passes:      i64 = 0
    @persistent var escalations: i64 = 0

    on msg Issue:
        if msg.severity == "error":
            errors = errors + 1
        else:
            warnings = warnings + 1
        response(rule=msg.rule, severity=msg.severity, errors, warnings)

    on msg Pass:
        passes = passes + 1
        response(rule=msg.rule, passes)

    on msg Escalation:
        escalations = escalations + 1
        response(reason=msg.reason, escalations)

// QA agent — runs on Claude; three distinct tools for issue / pass / escalate.
agent QAReviewer:
    kind:    reviewer
    persona: """
        You are a quality-assurance reviewer. For each piece of content you review:
        — Call Issue for any rule violation (set severity to "error" or "warning").
        — Call Pass for each rule the content satisfies.
        — Call Escalation if the content requires human judgment.
        Cite the rule name precisely. Be terse. No preamble.
    """
    model:   claude:sonnet
    memory:  rolling(turns: 10)
    budget:  <= 100k tokens / hour
    tools:   [ QALog.Issue, QALog.Pass, QALog.Escalation ]
    accepts: [ prompt ]

// showcase/08_research/research.borz
// Two-tier research pipeline: a fast gemma4:e2b classifier routes questions;
// a larger gemma4:12b researcher synthesises the deep ones.
// Both share one deterministic log actor — the typed contract is enforced at compile time.

msg Finding:
    depth:  str    // "shallow" | "deep"
    answer: str

msg Stats:

// Shared research log — deterministic, replayable.
actor ResearchLog:
    @persistent var shallow: i64 = 0
    @persistent var deep:    i64 = 0
    @persistent var total:   i64 = 0

    on msg Finding:
        total = total + 1
        if msg.depth == "deep":
            deep = deep + 1
        else:
            shallow = shallow + 1
        response(depth=msg.depth, shallow, deep, total)

    on msg Stats:
        response(shallow, deep, total)

// Fast-tier classifier — cheap model; runs on every question.
agent Classifier:
    kind:    classifier
    persona: "Classify this research question as 'shallow' (one-sentence fact) or 'deep' (requires synthesis). Reply with one lowercase word only."
    model:   local:ollama:gemma4:e2b
    memory:  none
    tools:   [ ResearchLog.Finding ]
    accepts: [ prompt ]

// Deep-tier researcher — larger model; for complex questions only.
agent Researcher:
    kind:    researcher
    persona: """
        You synthesise research findings into clear, precise answers.
        Keep answers to 3–5 sentences; cite key assumptions.
        After answering, call the Finding tool with depth="deep" and your answer.
    """
    model:   local:ollama:gemma4:12b
    memory:  rolling(turns: 6)
    budget:  <= 200k tokens / hour
    tools:   [ ResearchLog.Finding ]
    accepts: [ prompt ]