⏱️ 60 seconds to a real Dvalin scan

Install DvalinCode, then scan the current repository with the built-in rules and any supported open-source engines available on PATH:

curl -fsSL https://raw.githubusercontent.com/arthurpanhku/dvalincode/main/scripts/install.sh | bash
dvalincode trust
dvalincode dvalin . --scanners builtin,semgrep,trivy,osv-scanner

Use --fix --verify --in-place to let the configured model prepare focused repairs, run tests, and require a clean re-scan before the result can proceed to a draft PR. Dvalin never treats its health score as certification; source review and verification remain mandatory.

This animation is made from the real v0.14.0 application, not a mock. The input is an Apache-2.0-licensed example adapted from OWASP NodeGoat, whose contribution route evaluated user-controlled text.

🛡️ Dvalin is the security counterpart to Code

Code builds software. Dvalin is the second major product surface: it turns open-source scanner evidence into a controlled scan → fix → test → re-scan → draft-PR workflow.

Real v0.14.0 NodeGoat-derived run Before After Dvalin remediation
Security health (triage heuristic) 49 / 100 · F 100 / 100 · A
Findings 6 (eval across 2 rules) 0
Tests 2 passing 3 passing, including an injection regression test
Scanner fleet 4 / 4 completed 4 / 4 completed

The scanning and hardening control plane uses open-source components:

  • Semgrep CE and its community rules for semantic SAST.
  • Trivy for filesystem vulnerabilities, secrets, and misconfiguration.
  • OSV-Scanner with the open OSV database for dependency vulnerabilities.
  • DvalinCode's MIT-licensed built-in rules, remediation orchestration, test and re-scan gates, plus SARIF 2.1 import for other compatible scanners.

The scanners find and rank evidence. The configured model proposes source changes; DvalinCode constrains that work, records the diff, runs project tests, re-scans the changed tree, and keeps PR publication explicit. It does not auto-merge and it does not claim that a clean scan proves the absence of bugs. Choose an open-weight model through Ollama if the repair-proposal step must also stay fully local and open; hosted model licensing depends on the provider.

You can still prove what the agent did after the fact:

dvalincode report verify    # re-derive the hash chain of the last run's audit log

🎯 Core Goal

Make AI coding approvable for regulated and security-sensitive teams.

DvalinCode is built as an approvable agent runtime, not just another coding agent app. The core product is not only "AI writes code"; it is the evidence a security, compliance, or platform team needs to safely allow AI coding in financial services, healthcare, internal enterprise platforms, and other confidential codebases.

  • Any model — every OpenAI-compatible endpoint is a first-class citizen, local models included. Your workflow should never be hostage to one vendor's pricing, rate limits, or quality swings.
  • Safe by default — three-tier approvals with diff preview, an undo stack, and sandboxed shell execution. An agent you can trust on full-auto.
  • Small enough to audit — one ~25MB binary, a handful of runtime dependencies, a codebase you can read in a weekend. Trust through inspection, not promises. As of v0.5, every agent run is auditable too: a tamper-evident, hash-chained log of every action, verifiable after the fact.
  • Open enough to embed — the agent core speaks a clean REST + WebSocket API, ready to be wired into your own product, CI, or internal tools.
  • Approvable by any company — governance is built in, not bolted on. An org policy bounds the blast radius (controllable), dvalincode trust makes the posture self-verifiable (transparent), and the hash-chained log proves what every run did (auditable). Those three together are exactly what a security review needs to say yes — and what cloud, closed, mutable-log agents structurally struggle to provide. Approvability plan →

The bundled web GUI is the runtime's reference implementation and showcase — the first consumer of that public API, demonstrating everything the runtime can do.

✅ Why Teams Pick DvalinCode

DvalinCode is differentiated by approvability. It is built for teams that need AI coding to pass security, compliance, and data-governance review before it can touch production repositories.

  • Closed-loop secure remediation — scan locally or import SARIF from CodeQL, GitHub Code Scanning, Semgrep, or compatible scanners; persist findings as local remediation cases; create an isolated dvalin/remediate/... worktree; then send a focused repair prompt with source context and verification instructions.
  • Skills as governed operating procedures — upload, download, and inspect local skill bundles. Built-in secure scanning and remediation skills tell agents which tools to use and keep workflows portable across machines.
  • Model freedom without policy drift — use DeepSeek, OpenAI, Claude via OpenRouter, Groq, Ollama, or any OpenAI-compatible endpoint while keeping tool permissions, audit, and workspace policy consistent.
  • Security evidence, not just security claims — OpenSSF Scorecard support, CodeQL, Dependabot, pinned Actions, CODEOWNERS, ISO/IEC 42001 alignment docs, AI change-impact records, and hash-chained run logs are part of the project.
  • Local-first by default — sessions, config, profiles, memory, and audit logs stay under ~/.dvalincode/; .dvalincodeignore and policy controls bound what the agent can read, write, or execute.

🛡️ Security & Governance

DvalinCode maintains project-level governance evidence for open-source and enterprise review. This is the differentiator for teams where AI coding must pass security approval before it can reach production repositories:

  • Threat model — the full attack surface of an agentic coding runtime (malicious AGENTS.md, poisoned MCP servers, prompt-injection escalation, egress, audit tampering, supply chain, sandbox escape), each mapped to the control that defends it and the honest residual gap. Threat model →
  • OpenSSF Scorecard support — scheduled Scorecard workflow, SARIF upload, CodeQL, Dependabot, CODEOWNERS, least-privilege workflow permissions, and SHA-pinned GitHub Actions. Control map →
  • ISO/IEC 42001 alignment — an AI management system scope, AI policy, role map, risk register, AI change classification, required records, and review cadence. AIMS alignment →
  • AI change impact assessment — a reusable template for changes that affect model/provider behavior, prompts, permissions, tools, audit logs, or release security. Template →
  • Regulated-use posture — local-first data handling, policy-controlled autonomy, minimized audit records, and release supply-chain evidence for finance, healthcare, security-sensitive SaaS, and internal enterprise use.
  • Dvalin security engineering — the dedicated Dvalin workspace combines the built-in scanner with installed Semgrep CE, Trivy, and OSV-Scanner, normalizes SARIF findings, drives isolated test-backed fixes, and explicitly prepares a reviewable draft PR without auto-merging it. Workflow →

These documents are implementation evidence and operating procedures; they do not claim third-party ISO certification.

⭐ What's New in v0.14.0 — Dvalin security engineering

  • Home unifies Chat and Cowork — the GUI now has a single Home workspace with read-only Ask and approval-gated Collaborate intents, while keeping the same project and conversation context.
  • Code is focused again — the old Security and Routines panels have been removed from Code so its sidebar is dedicated to projects and autonomous implementation.
  • Dvalin is a first-class workspace — orchestrate the built-in scanner plus installed Semgrep CE, Trivy, and OSV-Scanner; import SARIF; score and triage findings; persist remediation cases; and create isolated repair worktrees.
  • One flow from evidence to draft PR — selected findings can launch an evidence-backed Agent fix, run focused tests/typecheck/build and a fresh scan, review the diff, and explicitly publish a draft PR without automatic merge.
  • Agent loops converge sooner and cost less — investigation-before-edit and stall detection reduce repeated failed actions, general tool output is bounded, prompts remain append-only for cache reuse, and provider usage now accounts for cache hits/misses.
  • Provider and evaluation upgrades — native Anthropic prompt caching and cache accounting are supported, and the SWE-bench Docker harness reports official scores, policy violations, stalls, and token/cache metrics.

⭐ What's New in v0.12.4 — finish the task before stopping

  • Process narration no longer ends a task — responses such as “let me verify the file” are recognized as pending work, and the agent immediately continues with the promised action instead of treating them as a final answer.
  • Truncated responses automatically recover — provider finish reasons are preserved, so output cut off by a token limit triggers another model step.
  • Normal coding turns get room to finish — the per-turn action limit is now an emergency 100-action guard rather than a routine 15-action stopping point; stricter organization policy limits still take precedence.
  • Completion is explicit — Code mode is instructed to return a tool-free answer only after the requested work and focused validation are complete.

⭐ What's New in v0.12.3 — resilient long-running Code mode

  • Long coding turns keep going — Code mode now compacts context during an active tool loop, accounts for the full provider request when estimating tokens, and raises the default iteration checkpoint from 10 to 40.
  • Interruptions are resumable — completed tool state is persisted when a turn is interrupted or its connection closes, so a follow-up continue resumes from the actual workspace progress.
  • Visible, quieter agent activity — running sessions show a sidebar loading state, each response reports elapsed work time, and its Action timeline is available on click while raw Tool Calls stay collapsed by default.
  • GitHub workflows from Code mode — network-aware git and GitHub CLI (gh) operations now support pull, push, PR creation, and Actions/repository commands through the governed shell approval path.
  • Safer releases — package and CLI versions are synchronized, and prepublishOnly runs the build, typecheck, and test suite before publishing.
  • Simple tasks stay simple — the Action budget is enforced across the whole turn instead of resetting on every model iteration, and Code mode is prompted to take the shortest direct path and stop when focused validation passes.

⭐ What's New in v0.12.2 — 🖥️ Desktop app milestone: it just works

  • 🖥️ The native desktop app now works out of the box on macOS — DvalinCode.app opens a real dock window (WKWebView, no Electron) over the embedded engine. Two threading bugs that shipped in every earlier desktop build are fixed: the blocking webview loop no longer starves the embedded server (blank window), and the webview runs on the main thread as macOS requires (no window at all) — the server now lives in a child process of the same binary.
  • 📦 The one-line installer installs the app — on macOS, curl … install.sh | bash now also puts DvalinCode.app (with the DvalinCode icon) into /Applications, so the desktop window launches straight from Launchpad after a CLI install. Opt out with DVALINCODE_NO_APP=1; pin with DVALINCODE_GUI_VERSION.
  • ✅ Desktop is no longer "experimental" on macOS — the window and the embedded server are verified working; Windows and Linux desktop builds are cross-compiled and remain a preview.
  • 🛡️ Secure remediation workflow — run a built-in local scan or import SARIF from CodeQL, GitHub Code Scanning, Semgrep, and compatible scanners; findings become local remediation cases with source context, verification guidance, and isolated worktree repair tasks.
  • 📚 Skills — upload, download, inspect, and reuse local skill bundles. DvalinCode now ships built-in secure-code-scan and secure-code-remediation skills, plus agent tools for listing skills, reading instructions, scanning, listing remediation cases, and preparing remediation worktrees.
  • 🔐 CodeQL path hardening — user-controlled workspace, remediation, and skill paths now go through explicit root-containment checks, with regression tests covering traversal-safe resolution and skill import boundaries.
  • 🎨 App icons — dark and light theme application icons now ship with the web bundle and desktop build inputs.
  • 🔒 Org policy — a dvalin.policy.json lets a company, not the developer, bound the agent: which modes, shell commands, file paths, tools, and models are allowed. Two layers (machine ~/.dvalincode/policy.json + repo) resolve by narrowing — a repo policy can only ever make the machine policy stricter, never widen it. With no policy file, behavior is identical to before. Enforced at a single chokepoint; every denial is an inline ⛔ Blocked by policy plus a policy_violation audit event. Policy reference →
  • 🔎 dvalincode trust — prints this install's live security posture in one command — active policy + source hashes, audit status, runtime, dependencies — so a reviewer can verify what the agent may and may not do directly, instead of taking claims on trust. --json for tooling.
  • dvalincode policy check — validates dvalin.policy.json against the schema, prints the resolved policy + canonical hash (after narrowing with the machine layer), and exits non-zero on failure — for CI and policy authoring. Policy reference →
  • 🧾 Policy-aware audit — every run records the hash of the governing policy (and which files contributed) in run_start, so the tamper-evident log proves which rules were in force.
  • 📐 Approvability plan — the through-line is documented in docs/APPROVABILITY-PLAN.md: make DvalinCode trivially approvable by any company — controllable, transparent, auditable.
  • 🧠 Portable memory & full data export/import — the upgraded local memory mechanism, plus every session, config, profile, and audit log, can now be bundled into a single file and restored on another machine. Migrate your whole setup in one step: dvalincode export / dvalincode import, or the Export / Import buttons in the GUI Settings panel.
  • 📝 Download any AI interaction as Markdown — every conversation can be saved as a clean Markdown transcript (user turns, assistant replies, tool calls + results, decisions — all inline). Use the download icon on any session in the sidebar, dvalincode session md <id>, or GET /api/sessions/:id/markdown.
  • 🖥️ Native desktop app — a real application window (not a browser tab) over the same engine: DvalinCode.app on macOS, plus Windows/Linux builds. Built with webview-bun using the OS-native webview (WKWebView / WebView2 / WebKitGTK) — no Electron, stays a small self-contained binary.
  • 🧩 A third frontend, one core — the desktop app, terminal UI, and web GUI all drive the same shared turn-runner. The current dvalincode binary is now positioned purely as the CLI (terminal + serve).
  • Status: the desktop binaries are experimental / unverified — grab them from the latest pre-release and please report how the window behaves on your OS.
  • 🖥️ Terminal agent — run dvalincode bare for an interactive terminal coding agent, Claude-Code-style: streaming responses, inline [y/N] write approvals with red/green diffs, /mode · /clear · /git · /plan · /compact · /undo · /help, Ctrl-C to interrupt, and a guided first-run provider setup. Defaults to read-only Chat, switchable live.
  • 🌐 dvalincode serve — the web GUI now lives behind a command, so the same binary deploys headless on a server: dvalincode serve --host 0.0.0.0 --no-open.
  • 🧩 One engine, two frontends — the terminal UI and web GUI both drive a shared, transport-agnostic turn-runner (src/agent/session.ts), keeping them at feature parity.
  • 🛡️ Security-grade audit trail — every Cowork/Code run writes a tamper-evident, hash-chained JSONL log to ~/.dvalincode/audit/ (run_start, every tool_call / file_* / shell_exec / approval, run_end). The hash chain makes any after-the-fact edit detectable. No local coding agent ships verifiable behavior logs. Format + threat model →
  • 📋 Run Report + dvalincode report CLI — a Markdown summary of each run (files read/changed, commands, decisions, test result), rendered as a collapsible card in the GUI and from the CLI: 
    dvalincode report --last           # render the most recent run
dvalincode report <run-id> --format json
dvalincode report verify <run-id>  # ✓ chain intact / ✗ broken at seq N
  • 🎨 Theme switcher — choose dark / light / system in Settings. system follows your OS live; the choice persists across sessions.
  • /compact — LLM-based context compaction: replaces conversation history with a structured five-section summary (Goal / Completed / Decisions / Current State / Pending). A divider in the chat thread shows the token reduction (e.g. 8,412 → 1,203 tokens −85%).
  • dvalin.json team playbook — commit a shared set of automation prompts to your repo. The sidebar loads them automatically and lets teammates run the same one-click routines without any manual setup. Export button converts your personal routines to dvalin.json in one click.
  • Self-contained binaries — single ~25 MB executable per platform; no Node, no Python, no Docker. Auto-opens your browser on launch. Built with bun --compile so the web UI is bundled alongside the server binary.
  • Mode-aware sidebar — Chat shows quick-prompt Templates, Cowork shows a Projects folder tree, Code shows custom Routines (one-click commands like "Run tests" / "Git status" / "Type check"). Add your own routines from the sidebar — they persist in localStorage.
  • One-line installer — curl … | bash auto-detects your OS + arch, drops the binary into ~/.dvalincode/, and patches your PATH. No package manager dependencies.
  • Multi-profile LLM config — save named (provider, model, API key) sets and switch in one click from the sidebar; live per-session cost counter in the topbar so you can compare providers on the fly.

📸 Preview

A real Dvalin scan of vulnerable code — 6 findings, 49/F:

The verified result — three source fixes, one new regression test, all four open-source scanner integrations complete, 0 findings, 100/A:

Home → Code → Dvalin — the current v0.14.0 workspaces:

The images above were captured from the v0.14.0 UI while running the documented NodeGoat-derived case. Older Chat/Cowork/Routines and legacy terminal recordings have been removed so every README product image matches the current app.

🆚 When to choose DvalinCode

If you need… DvalinCode's answer
An agent your security team can approve Policy-bound tools, explicit approval modes, dvalincode trust, audit logs, OpenSSF evidence, and ISO/IEC 42001 alignment docs.
AI coding for regulated repositories — finance, healthcare, enterprise data, customer-confidential code Local-first runtime, bring-your-own-model, .dvalincodeignore, governed egress, and minimized audit records.
A safer alternative to generic autonomous coding agents The product thesis is controllable / transparent / auditable, not only "the model can edit files".
IDE-centric AI workflows Zero-dep binary (~25 MB). Runs anywhere, no IDE required. macOS shell is sandboxed by default — network denied, writes capped to cwd.
Terminal-first AI workflows CLI start → auto-opens a modern Web UI with code highlighting and red/green diff approval. One install command, nothing else needed.
Cloud-only AI workflows Every OpenAI-compatible endpoint is a first-class citizen. Run Ollama with Qwen2.5-Coder: no key, no internet, no per-token cost.
Single-machine AI setup AGENTS.md committed to the repo ships AI context to every clone. dvalin.json ships the team's automation commands the same way — export from the sidebar, commit, done.

🚀 Quick Install

macOS / Linux (one-liner)

curl -fsSL https://raw.githubusercontent.com/arthurpanhku/dvalincode/main/scripts/install.sh | bash

Detects your OS + arch, downloads the right binary, installs to ~/.dvalincode/, and adds it to your PATH. On macOS it also installs the native DvalinCode.app into /Applications (skip with DVALINCODE_NO_APP=1), so the desktop window launches straight from Launchpad. After reload:

source ~/.zshrc    # or ~/.bashrc
dvalincode                       # interactive terminal agent
dvalincode dvalin .              # white-box security scan (GUI-independent)
dvalincode serve                 # start the web GUI, open the browser
dvalincode serve --host 0.0.0.0 --no-open   # host it on a server for remote/browser use
echo "inspect src and summarize" | dvalincode run - --output-format stream-json
dvalincode mcp-serve             # task-level stdio MCP server for external agents

Headless run and mcp-serve keep the same policy and audit chokepoint as the interactive clients. See the unattended recipes for cron, CI, and external-agent examples.

Windows

Download dvalincode-v*-windows-x64.zip from Releases, unzip, then double-click start.bat.

Manual download

Grab the archive for your platform from the Releases page:

Platform Archive
macOS Apple Silicon (M1/M2/M3) dvalincode-v*-macos-arm64.tar.gz
macOS Intel dvalincode-v*-macos-x64.tar.gz
Windows x64 dvalincode-v*-windows-x64.zip
Linux ARM64 dvalincode-v*-linux-arm64.tar.gz
Linux x64 dvalincode-v*-linux-x64.tar.gz

Verify against SHA256SUMS.txt (included in each release).

macOS Gatekeeper: binaries are unsigned. On first run, either clear the quarantine flag with xattr -dr com.apple.quarantine ~/.dvalincode, or right-click the binary in Finder → Open → confirm.

Staying up to date

DvalinCode updates itself — no need to re-run the installer:

dvalincode update --check   # is a newer release out? (read-only)
dvalincode update           # download, verify, and install the latest

It finds the newest release on GitHub, and for a binary install downloads the matching archive, verifies it against the release's SHA256SUMS.txt before swapping anything in, then replaces ~/.dvalincode/ in place. npm installs are updated via npm i -g, and source checkouts are pointed at git pull. Add -y to skip the prompt, --prerelease to track pre-releases, or --json for scripting.

The macOS desktop app checks the separate gui-v* release track when it starts. When a newer GUI is available, it asks before downloading, verifies the archive against SHA256SUMS-gui.txt, validates the app version, then replaces and restarts DvalinCode.app. A failed replacement rolls back to the previous app.

🎬 First-time setup

Terminal (default): run dvalincode. On first launch it walks you through a one-time provider setup (pick a provider, paste your API key, choose a model) and saves it to ~/.dvalincode/config.json. Then you're at the prompt — type to chat, /mode to switch between Chat / Cowork / Code / Dvalin, /help for commands. In the GUI, Chat and Cowork are grouped under Home.

Web GUI: run dvalincode serve and:

  1. The server starts on http://localhost:3000 and your browser opens automatically.
  2. Click LLM Configuration in the sidebar (bottom-left).
  3. Pick a provider, paste your API key, choose a model, hit Save.
  4. Optional: save the current config as a named profile (e.g. fast, cheap, local-ollama) to switch quickly later.

Both share the same config and sessions in ~/.dvalincode/.

✨ Features

Category Feature Notes
Modes Home / Code / Dvalin Home contains read-only Ask and approval-gated Collaborate; Code is focused autonomous development; Dvalin is the scan-to-fix security workspace
Code permissions Ask Permissions / Plan Mode / Auto Mode / Bypass permissions Verified behavior: Ask requests approval before writes/commands, Plan is read-only and does not write files, Auto runs operations automatically, Bypass runs without confirmation prompts
Workspaces Open folder / Import Git / Add worktree Cowork and Code can switch to a local folder, clone a Git project, or create a Git worktree from the UI
Governance OpenSSF Scorecard / ISO 42001 AIMS alignment Scorecard, CodeQL, Dependabot, pinned Actions, AI impact assessment, risk register, and review cadence are documented under docs/security/ and docs/governance/
Secure remediation Built-in + Semgrep CE + Trivy + OSV-Scanner / SARIF / cases / worktrees / tests / draft PR Dvalin detects installed engines, normalizes SARIF, scores risk, persists cases, drives evidence-backed fixes, verifies changes, and publishes only after an explicit user action
Skills Upload / download / built-in security skills Skills live under ~/.dvalincode/skills; built-ins guide security scanning and remediation with dedicated agent tools. Format →
Composer @ file references Type @ for a fuzzy file search; selected files get inlined into the prompt
/ slash commands /clear /compact /git /plan /undo /help
Multiline + interrupt Shift+Enter for newline, stop button to abort mid-stream
Tool UI Inline diffs edit_file and write_file results render as red/green unified diff, default folded
Approval dialog with diff Cowork mode shows the diff before the change is applied
Live tool counter + token + cost Topbar shows session totals in real time
Agent LLM-based context compaction /compact summarises into Goal / Completed / Decisions / Pending
Persistent undo stack /undo [N] reverses the last N tool calls
Run Report Markdown summary per run (files, commands, decisions, test result) — GUI card + dvalincode report
Git awareness Branch name in topbar; git_status tool; git context auto-injected into prompt
AGENTS.md project memory Per-repo persistent instructions, auto-loaded each turn
Security Tamper-evident audit trail Hash-chained JSONL per run in ~/.dvalincode/audit/; dvalincode report verify detects edits
macOS shell sandbox sandbox-exec denies network; allows writes only inside cwd + /tmp
.dvalincodeignore gitignore-style exclusion; blocks read_file / list_files / search_text
Per-action approval Approve/deny each write / delete / shell call in Cowork mode
Appearance Theme switcher Dark / light / system, persisted; system follows the OS live
Providers OpenAI-compatible endpoints DeepSeek · OpenAI · Groq · OpenRouter · Ollama · custom
Multi-profile config Save and switch between named (provider, model, API key) sets
Sessions Auto-save + restore All sessions persisted to ~/.dvalincode/sessions/ as JSON
LLM summary memory Cross-session summary keeps the agent oriented after restart
Memory Local user/project memory Searchable facts, preferences, and decisions in ~/.dvalincode/memory/; import from Claude/Hermes/Markdown
Data portability Export / import all data One bundle of memory + sessions + config + audit — dvalincode export / import, or GUI Settings → Export / Import
Markdown transcript Download any conversation as Markdown — sidebar download icon, dvalincode session md <id>, or /api/sessions/:id/markdown

⌨️ Slash Commands

Command Description
/clear Clear the current conversation (client-side, starts a fresh session)
/compact LLM-based context compaction — replaces history with a structured summary
/undo [N] Reverse the last N tool calls (default 1)
/git Run git_status and show branch, recent commits, changed files
/plan <task> Ask the agent to plan the task step-by-step without executing
/help Show all available slash commands

🛠️ Architecture

┌───────────────────────────┐   ┌─────────────────────────┐
│  Terminal UI (readline)   │   │  Browser GUI (React/Vite)│
│  streaming · approvals    │   │  ChatThread · DiffViewer │
└─────────────┬─────────────┘   └────────────┬────────────┘
              │ in-process          HTTP / WebSocket
              │                ┌───────────────▼─────────────┐
              │                │  Express + ws server         │
              │                │  /api/* · `dvalincode serve` │
              │                └───────────────┬─────────────┘
              └──────────────┬─────────────────┘
┌────────────────────────────▼────────────────────────────┐
│  runAgentTurn — shared turn-runner (src/agent/session)   │
│  provider · prompt (mode · git · AGENTS.md) · session    │
└────────────────────────────┬────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────┐
│                    Agent Engine                          │
│  AgentLoop (8-state machine) → AgentRunner              │
│  Streaming · In