What this article covers
What Lume is, how bridge.c bridges the DSL to C, and how the VM and GC are reused across requests are all dissected source-by-source in a dedicated article (https://erishen.cn/lume/); none of that is repeated here. This piece answers a different question: once the implementation is set aside, what capabilities does the language actually put in a developer's hands, and how can you verify they are real on the spot?
The answer is not in slogans but on a public instance. It exposes Lume's type core, three execution paths, built-in HTTP, algorithm library and the deterministic Agent demo as /api/* endpoints — the public part is readable against source and callable with curl; host-side LLM integration and native tool execution have no public endpoint and can only be verified by source and runtime tests. Follow that thread below.
Here is what it actually looks like. These are two routes from server.lume in the showcase, not pseudocode:
get "/api/health", (req) => {
return json_resp(stringify({ ok: true, service: "lume-showcase", cores: 1 }));
};
get "/api/features", (req) => {
return json_resp(stringify(feats.feature_list()));
};
One get statement registers a route; a handler returns a map that the framework serializes as JSON. There is no hand-assembly beyond stringify, no manual status/type. At the end of the file the server capability is declared:
server {
host = bind_host;
port = 18793;
docroot = "web/dist";
}
run();
server{} is built into the language, not an imported framework, and run() turns all of it into a listening process. A static site (docroot) and JSON APIs are served by the same process — that is the deploy glue Lume sets out to remove.
TL;DR
- Static types and algebraic data types: enum + exhaustive
match, higher-order functions,Result+?error propagation and module imports are in the language, not a library. - One frontend, three execution paths: the parser emits a typed AST, which forks into a tree-walking interpreter, a hand-written LLVM IR text backend and a libLLVM C API backend — all three agree byte-for-byte on the same source.
- HTTP is a language capability:
server{}+run()stand up a static site and APIs,get/writestatements register routes; production needs no Node.js and no separate application server. The React frontend is built ahead of time and served by Lume's built-in HTTP server alongside the API in one process. - Numerics and ML are part of the language's territory: dedicated libraries for matrices, linear algebra, integration, optimization, MLP, PINN and PDE across twelve algorithm families; three speedups come from real measurements.
- The agent surface is built into the language:
catalog()/tools()/mcps()/skills()introspection builtins, an external-model hook through environment variables, and a native ReAct agent at the host layer (the model writes SQL,sql_queryexecutes it read-only, and the answer comes from real rows) — no Python, MCP stdio or Node sidecar required. The pure-lume loop in the showcase is just one customizable example. - Public capabilities are verifiable live: the public instance exposes the language core, execution backends, HTTP, algorithm library and the deterministic Agent demo as
/api/*endpoints, with page numbers coming straight from interpreter return values; host-side LLM and native tool execution are verified by source and runtime tests, not by a public endpoint. - Light enough to spread out: no Node runtime in production, an image around 12MB (a scratch base; the bare static binary is smaller still), so a single minimal ECS box can run several instances by port.
The four layers: from applications down to the native runtime
The seven points above live at different layers. Here is where they sit:
Applications
Web / CLI / Agent / MCP
|
Lume Server
HTTP / SQL / Tools
|
Lume Core
Parser / Type Checker
Interpreter / LLVM
|
Native Runtime
C11 / SQLite / C Kernels
Read bottom-up: a native runtime of C11, SQLite and numerical C kernels; Lume Core on top of it with parsing, type checking and the three execution paths; Lume Server turning HTTP, SQL and tool registration into language capabilities; and applications — Web, CLI, Agent, MCP — at the top. Every section of this article has a place in that picture, and the showcase is only one public verification window at the topmost layer.
The language core: types, enums and Result
Lume's types are not comments on variables; they are constraints the compiler reasons about. This self-check from src/features.lume shows annotations, inference and int→float widening:
func demo_types(): string {
let a: FPoint = { x: 3, y: 4 };
let dx = a.x; // inferred int
let w: float = 7; // int literal widens to float
return "p=" + str(a) + " dx=" + str(dx) + " widened=" + str(w);
}
FPoint is a type alias declared at the top of the file, let dx = a.x infers int, and let w: float = 7 widens the integer literal to float. Enums plus pattern matching are how Lume handles algebraic data types:
enum FShape { Cir(r: float) | Rect(w: float, h: float) }
enum FColor { Red | Green | Blue }
func demo_enum(): string {
let s = Cir(2.0);
let area = match (s) { Cir(r) => 3.14 * r * r, Rect(w, h) => w * h };
let name = match (s) { Cir(r) => "circle", Rect(w, h) => "rect" };
let c: FColor = Green;
let word = match (c) { Red => "stop", Green => "go", Blue => "cool" };
return "area=" + str(area) + " " + name + " " + word;
}
match is exhaustive (both FShape cases and all three FColor cases are covered), and r, w, h in the patterns bind the enum payload directly. Error propagation uses Result with the ? operator, removing a layer of if err checks:
func demo_result(): string {
let ok_part: Result = _report_ok();
let e: Result = _divide(1, 0);
return get(ok_part, "ok", "?") + " err=" + str(get(e, "err", ""));
}
func _report_ok(): Result {
let q: float = _divide(21, 7)?;
return { ok: "q=" + str(q) };
}
func _divide(a: int, b: int): Result {
if (b == 0) { return { err: "div by zero" }; }
return { ok: a / b };
}
_divide(21, 7)? unwraps the ok value on success and propagates the err on failure. These are not slideware — they are collected by feature_list(), returned by /api/features and actually executed on the interpreter. Two deliberate language disciplines are worth remembering: / is always float (7 / 2 gives 3.5, not a truncated 3), and lists have reference semantics (push mutates in place). The first avoids silent integer-division truncation; the second matters for how containers move through algorithm code.
One frontend, three execution paths
Lume's execution model forks rather than pipelines: a shared frontend (lexer / parser / type checker) emits a typed AST, which splits into three non-serial paths — a tree-walking interpreter, a hand-written LLVM IR text backend and a libLLVM C API backend. All three consume the same AST instead of a "frontend → interpreter → backend" chain.
Why keep three? Because consistency is itself a capability: tests/smoke.sh starts servers on the interpreter, the text backend and libLLVM, then compares every /api/* endpoint for byte-for-byte identical JSON. The same .lume code therefore cannot drift between interpreted and natively compiled execution — which is exactly how a language shrinks the surface an AI-generated program must get right.
The cost is that boundaries must be explicit. Some interpreter-side builtins (the HTTP client http_get with its SSRF gate, and the agent-introspection catalog/tools/mcps/skills) do not exist in the compiled backends. The showcase's agent demo therefore deliberately uses only pure lume — give up a builtin rather than break byte-identical output across backends. That discipline runs through the whole project.
Built-in HTTP: server{} is not a framework
We have already seen server{} and the get routes. What matters is their nature: HTTP is a language builtin, not an imported web framework, and you do not need nginx in front of the process to act as application server. To be precise about the boundary: the React frontend is still built with Vite, so the Node toolchain is needed during development and build; but once the static assets exist, production needs neither Node.js nor a separate application server — Lume's built-in HTTP server serves web/dist alongside the API in one process. Public HTTPS still needs a reverse proxy for TLS termination, a layer Lume does not cover. server.lume lists one of its twelve application categories as "static site + API in one process":
out = push(out, { name: "static site + API in one process",
desc: "docroot static + route API · single binary process",
libs: "server{}", status: "ok" });
docroot points at the frontend build output web/dist; once the production build exists, the same process serves both APIs and static assets. Deployment collapses to one binary and one port: local runs bind 127.0.0.1 by default (safe by default), while containers switch to 0.0.0.0 via an environment variable. For HTTPS on the public internet you still need a reverse proxy for TLS termination — Lume deliberately does not cover that layer, and says so up front.
Numerics and ML: the language's own algorithm territory
A language aimed at agents should not force you to write matrix or differential-equation loops from scratch every time — that just moves the glue from the web layer to the algorithm layer. Lume's answer is dedicated standard libraries, and src/algorithms.lume lays out twelve families: dense matmul (blas), PINN, MLP backprop, linear algebra (LU/QR/eigen/SVD), numerical integration, gradient descent, k-means, 1D heat equation (PDE), KL divergence, complex arithmetic, signal smoothing and graph BFS. Each carries a mini demo that really ran, such as gradient descent converging to the minimum:
func demo_gd(): string {
let x = 0.0;
let lr = 0.1;
for (let i = 0; i < 50; i = i + 1) {
let grad = 2.0 * (x - 3.0);
x = x - lr * grad;
}
return "gd_min=(x-3)^2 -> x=" + str(x);
}
Harder evidence is performance. bench() in server.lume collects three measured speedups:
out = push(out, { name: "wall 1 · PINN analytic gradient",
from: "4.5 min (numeric)", to: "1.3 s (analytic)", speedup: 207, ... });
out = push(out, { name: "wall 2 · codegen vs C",
from: "1.00x (C)", to: "1.02x (lume)", speedup: 1.02, ... });
out = push(out, { name: "wall 3 · blas C kernel",
from: "0.60 s (pure lume)", to: "0.05 s (C kernel)", speedup: 12, ... });
207× comes from replacing numeric gradients with analytic ones in PINN training, 1.02× is the compiled backend matching C on a scalar loop, and 12× is the C-kernel matmul over a pure-lume loop. The test conditions for all three are recorded in the note field of bench() and can be fetched verbatim from /api/bench:
| Figure | Conditions (source note) |
|---|---|
| 207× | training, compiled backends; loss 0.573 → 0.00224, relative L2 error 1.43% |
| 1.02× | scalar loop, codegen reaching C speed |
| 12× | 128×128 matrix, 30 runs, bit-identical results |
Each is a comparison under specific conditions, not a blanket "Lume is N times faster than language X" claim — 207× compares analytic against numeric gradients (two algorithms), and 12× compares a C kernel against a pure-lume loop (two implementations). The source does not record the test hardware, so no unverifiable environment details are added here; re-run under the same conditions for your own comparison. These numbers are legitimate not because of where they are written, but because they flow only from bench() through /api/bench into the chart — the frontend cannot massage a value to make the graph look better.
Benchmark Methodology (known limits): every condition above comes from the note field of bench() in server.lume, returned verbatim by /api/bench for your own check. The source does not record CPU model, compiler flags, full iteration setup or measurement tooling, so no unverifiable environment details are invented here — re-run under the same conditions to compare. These figures show how much a given optimization changed things, not a cross-language performance ranking.
The agent surface: introspection builtins, an LLM hook and native ReAct
Lume is billed as "a DSL for agent applications". What it hands the developer is not a reference loop but three ready-made layers:
One clarification up front: the showcase Agent demo on this page uses a deterministic policy and makes no external LLM calls. The native LLM integration and ReAct execution described above are provided by the host runtime; the public demo deliberately avoids them to keep the three backends byte-identical.
Introspection builtins, defined in lume-core's builtins_catalog.c: catalog() returns a { skills, tools, mcps } registry snapshot in one call, tools() lists tool names, descriptions and OpenAI-style parameter schemas, mcps() returns the gateway plus local MCP servers (source-tagged), and skills() lists named skill capabilities. Call them directly from a script — no config-file parsing of your own. Note these are interpreter-side: the language tree ships an empty registry (signatures and semantics are present, just nothing to enumerate), while the host tree reads the table from agent-httpd's registry. Which layer a script runs on determines what it enumerates.
The LLM hook: LLM_API_URL / LLM_MODEL (with LLM_API_KEY) wire in an external model through environment variables. The backend is external and optional; the language binds itself to no vendor. Which endpoint data flows to is your configuration, so third-party use needs your own assessment of what crosses the boundary.
The native ReAct agent, at the host agent-httpd layer: this is a genuine multi-round loop — agent.c calls the model once per round up to AGENT_MAX_ROUNDS (default 8), feeding each round's tool results back as observations into the messages array, so the model can decide again, and emits the final answer from the model itself in the last round rather than from a host-side template. Tool output, including SQLite's errmsg, is written into the result text and fed back, so the model can re-decide and retry SQL on failure. In the SQL scenario the model writes SQL and sql_query runs it read-only in-process (sql_write only when explicitly whitelisted), with no Python, MCP stdio process or Node sidecar in between. With SQLITE_DB set, the server injects the live schema, row counts, sample values and FK hints into the system prompt so the model writes correct read-only SQL against real names instead of guessing; answer rules force grounding in returned numbers only.
So what is src/agent.lume in the showcase? It is one customizable example on top of those three layers: it deliberately avoids every interpreter-side builtin and writes a deterministic plan → act → observe → refine loop in pure lume (square, then accumulate), so all three backends agree byte-for-byte on the same code — that is what the /api/agent endpoint displays. The three layers above are Lume's built-in agent capability; this loop is only a demonstration of "you can write your own", not the ceiling.
Putting it together: from a natural-language task to executable numerics
Connecting the layers answers "why Lume rather than Go, Python or TypeScript". Follow one neutral task chain — a user gives a plain-language request and the system must produce a trustworthy numeric result:
User: "smooth this series of observations and estimate the least-squares fit"
|
v
Task recognition (host ReAct agent, LLM parses intent)
|
v
Tool selection (catalog()/tools() reveal available capabilities)
|
v
Numerical libraries (signal smoothing / linear algebra / gradient descent)
|
v
In-process execution (sql_query fetches data · lume algorithm libs compute)
|
v
Real results fed back (numbers computed, not invented by the model)
|
v
Report generation (structured output, served as a static site or API)
Every link in that chain is already built in: introspection tells the agent what tools exist, the numerical libraries give it something to call, native ReAct runs the loop in the host runtime, and built-in HTTP turns the result into a reachable endpoint. Covering "intent → tool → computation → output" in one language removes three pieces of glue — a Python script, a Node middle tier and a separate API service. That is what sets it apart from a general-purpose web DSL. The capability belongs to the language and runtime; the concrete business semantics are up to the .lume scripts and model you wire in.
Application landscape: what the language already runs
A language's capability ultimately shows in what it can carry. apps() in server.lume lists twelve shapes: HTTP API/web services, scientific CLI, ML training and inference, PINN solvers, PDE numerics, data pipelines, static site + API in one process, MCP servers, graph/signal/statistics tools, SQLite storage, crypto/hash and optimization. Every entry is marked status: "ok", which means the capability is implemented and has runnable code — a mini demo, a CLI tool or a deployable service all qualify; ok does not mean every application shape in that category has production-grade validation (error handling, monitoring and capacity planning are a separate matter). This is not a roadmap; it marks the point where Lume moves from "a compiler that runs" to "an application landscape around a language" — and the next section shows one of those shapes running as a real system.
Vertical application: lume-scanner runs the three layers as one system
The previous sections inventory capabilities; this one shows them closing the loop in a real business. lume-scanner is an A-share full-market technical-signal dashboard: an upstream Python ETL in stock-analyzer computes signals and indicators daily into two SQLite databases, and lume-scanner serves those two databases read-only as HTTP APIs from a single Lume C11 binary, with a React SPA on the front — one process, one static binary in production. It is a concrete answer to "what can Lume carry", not another capability demo.
Here is where the layers above land:
| Layer | Where it shows up in lume-scanner |
|---|---|
| Built-in HTTP | A single scanner.lume declares 11 /api/* routes plus /discovery with server{}; the SPA and API share the process |
| Numerics and ML builtins | /api/indicators/:code recomputes live with Lume builtins — KDJ / Williams / ATR / OBV / MACD / RSI (Wilder + Cutler) / Bollinger, plus a Sharpe / Sortino / CVaR / VaR performance panel — reading raw OHLCV rather than ETL indicator columns |
| Agent surface | AI chat is wired to whitelisted read-only tools (scan_signals / stock_kline / sql_query, etc.); model-driven multi-round tool calls require LLM_API_KEY to be configured |
| Native C11 / SQLite | One static binary opens both databases read-only; user input binds through ? placeholders; sql_query is physically SELECT-only |
The clearest demonstration of "semantic consistency" is a cross-check: Cutler RSI computed by the upstream Python ETL with pandas agrees with Cutler RSI recomputed by Lume's rsi_cutler builtin. Here is the exact unit: 80 is the default limit of /api/signals — the top 80 signals of the latest trading day sorted by confluence, each one a per-stock RSI comparison (not 80 indicators or 80 parameter sets). Each row counts as a match when |Δ| < 0.05; measured result: 80/80 all match, with an observed difference of 0. The 0.05 threshold is the criterion; the observed zero is the outcome, not the criterion — keep the two separate. Core-side quant builtins additionally have cross-backend consistency tests pinned to Python reference values. That is no coincidence — both sides are independently pinned, which is what makes "Lume's RSI" and "pandas' RSI" an assertable equality. The byte-identical three-backend property from the "one frontend, three execution paths" section above lands here as "the results line up with a mature ETL".
The chat has two modes, and the boundary is worth stating: with LLM_API_KEY it runs model-driven multi-round tool calls — the model understands the question, picks a whitelisted read-only tool and answers from real returns; without a key it falls back to the host's built-in C demo engine, which streams a canned reply word by word and only knows a few built-in topics (greetings / agent-httpd / streaming / SSE). It does not query the database or answer stock questions — its only purpose is to let the SSE streaming path be demonstrated without credentials. It is a degraded fallback, not a backup agent that can query offline.
Read-only does not mean read blindly. A window-function scan over 180 days of track record sweeps roughly 8.5M rows and takes nearly 8 seconds, so data is served through tiered TTL caches (meta 5 min, signal-stats 30 min, daily-picks 10 min, real-time quotes 15–30 s) and /api/freshness exposes the database's last update time so downstream callers can judge freshness. Security boundaries are built into the architecture too: bound to 127.0.0.1 by default with Basic Auth required before exposure, read_file locked to the web root to stop path traversal, and the database mounted :ro in the container.
The boundary matters: lume-scanner does not produce signals — signal generation and backtesting stay in the Python ETL; lume-scanner consumes its output read-only and verifies consistency. Lume owns the read-side service layer, the live indicator recomputation and the trustworthy presentation. The data comes from public market feeds, the project is a local research tool, it collects no personal data, and nothing it outputs is investment advice. The 11 routes, the cache tiers and the bit-for-bit reconciliation are detailed in the dedicated article; what matters here is only what it proves — one language plus one static binary can turn "fetch → compute → verify → present" into a deployable system.
Deployment cost: no Node, an image around 12MB
A language that can run applications is not enough — it has to be cheap to spread. Lume has a structural advantage here: its runtime is a statically linked C11 binary with no Node, no Python and no JVM. Remove a runtime and you remove a whole dependency tree from the image.
The main image uses Docker's empty scratch image as its base — no OS, toolchain or package manager — assembling only the static binary, busybox, CA certificates and static assets. The result is an image around 12MB (the bare static binary alone measures under 5MB). For contrast, a comparable service carrying a Node runtime typically lands in the hundreds of megabytes. There is no shell, package manager or compiler in the image, and credentials arrive only through environment variables, so the attack surface shrinks with it.
Where a small image really pays off is in the cloud: one minimal ECS box can run several Lume instances by port, each swapping in a different .lume script, a port and an allow-list of environment variables, with the static web root shared. This is not hypothetical — the compose file in Lume's main repository (docker/docker-compose.yml) does exactly that: several services (invest, hub, and others) share one image and one docroot through a common YAML anchor, differing only in their .lume script, host port and skill/tool allow-list. Only quantifiable gains are claimed here: an image around 12MB, a single static runtime, no Node/Python/JVM runtime dependency, multiple instances sharing one image and static assets, and simpler container deployment and upgrades. A smaller image does not imply an order-of-magnitude gain in instances per host — runtime memory and CPU depend on the workload, and this article has no same-hardware, same-load comparison, so no such figure is given.
The deployment implication: a "server that runs a language" compresses into "drop a ~12MB image, open a port." Edge nodes, low-cost cloud hosts and one-shot task containers — scenarios where you used to weigh whether a full runtime was worth it — can now be filled with a single .lume file and a small image.
Verify it live: the showcase is the window, not the subject
The capabilities exposed on the public instance can be verified without trusting this article. That is why the showcase exists — it is a verification window for Lume's capabilities, not the project being shown off. Draw the boundary clearly: host-side LLM integration, introspection builtins and native tool execution have no public endpoint; they are verified by source and runtime tests. The /api/agent endpoint is only a deterministic pure-lume demo, not a live demonstration of the host's native agent.
Here is where each capability lives and how it is verified:
| Capability | Implemented in | Verified by |
|---|---|---|
| Type system | lume-core | /api/features |
| Three execution paths | lume-core | tests/smoke.sh |
| HTTP server | lume (agent-httpd) | /api/health |
| Numerical algorithms | src/algorithms.lume |
/api/algorithms |
| Benchmark | server.lume |
/api/bench |
| Deterministic agent | src/agent.lume |
/api/agent |
| Agent introspection | builtins_catalog.c |
host runtime tests (no public endpoint) |
| LLM tool execution | agent-httpd | integration tests (no public endpoint) |
The first six are curlable on the public instance; the last two belong to the host side and can only be checked by reading source or running your own host runtime — the table exists to keep the two from being conflated.
Six data endpoints are exposed by server.lume and returned after the interpreter executes them:
/api/overview /api/features /api/algorithms
/api/apps /api/agent /api/bench
The frontend web/src/api.ts only parses the { status, type, body } envelope lume-core returns; failure throws, so there is no local constant to fall back on:
async function getJson<T>(path: string): Promise<T> {
const res = await fetch(path);
if (!res.ok) throw new Error(`${path} -> ${res.status}`);
const env = await res.json();
return JSON.parse(env.body) as T;
}
Every number on the page can therefore only come from a real run. Consistency between items, translations and detail entries is squashed into an exit code by tests/check_coverage.py: it pulls six lists from the running service and checks that each English name hits both zhDict and the detail table in content.ts, printing the missing ones and exiting 1 on drift. Runtime constraints live in the image — the Dockerfile health verdict is not "the process is alive" but the string "status":200 in the body:
EXPOSE 18793
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD wget -q -O - http://127.0.0.1:18793/api/health | grep -q '"status":200' || exit 1
The final image stage carries no node and runs as a non-root user; the writable SQLite directory /app/data is created up front and owned by that user, so the service comes up under a read-only root filesystem. All of those constraints serve one goal: replace "we measured it" with "here is how you measure it again".
Reproduce: three commands
curl http://127.0.0.1:18793/api/health # expect "status":200
curl http://127.0.0.1:18793/api/features # 12 language features, really returned by the interpreter
curl https://lume.erishen.cn/api/bench # three measured speedups on the public instance
The first two target a local process (after starting the service per the README); the third targets the public instance — both return the same { status, type, body } envelope. To verify the container too, follow the README's docker build + docker run --read-only sequence; the health check and a manual curl use the same criterion.
Source code navigation
Three repositories, one per layer — take what you need:
- Lume (the DSL server and container image): https://github.com/erishen/lume
- lume-core (the language, interpreter and compiler): https://github.com/erishen/lume-core
- lume-showcase (the public instance behind this article): https://github.com/erishen/lume-showcase
Live: https://lume.erishen.cn
The body names files and symbols only; line numbers are omitted because they drift with every commit — search by symbol or by the quoted snippet.
server.lume— route registration,apps(),bench(),server{}andrun()src/overview.lume— the "what is Lume" tour andoverview_sections()src/features.lume— language feature self-checks andfeature_list()src/algorithms.lume— twelve algorithm demos andalgorithm_list()src/agent.lume— the customizable pure-lume agent-loop example andagent_list()tests/check_coverage.py— item/translation/detail drift detectiontests/smoke.sh— byte-for-byte consistency across three backendsDockerfile— read-only container and health checkweb/src/api.ts— envelope parsing and the six data entries
How does this differ from the article "Lume: a C11 single-binary Agent DSL server"?
The two split the work. That one looks inward: the bridge.c contract, VM reuse after fork, the value-stack-as-GC-root memory model, all checked line by line against source. This one looks outward: what capabilities the language hands you (type core, three backends, built-in HTTP, algorithm library, agent surface) and how to verify each on a public instance. Read that one to audit the implementation; read this one to see what you can build with it and whether it is really there. Together they are the full picture.
What exactly does "byte-identical across three backends" verify?
tests/smoke.sh starts servers on the interpreter, the hand-written IR-text backend and libLLVM, then compares every /api/* endpoint for byte-for-byte identical JSON. The cost is that some interpreter-side builtins (the SSRF-gated http_get and the agent-introspection interfaces) are absent from the compiled backends, so the showcase’s agent demo uses only pure lume to preserve that identity.
Is Lume's agent capability built in, or do you write it yourself?
Three layers are built in — the catalog()/tools()/mcps()/skills() introspection builtins, the LLM_API_URL/LLM_MODEL external-model hook, and the native ReAct agent at the host layer. The pure-lume plan → act → observe → refine loop in the showcase is just one customizable example: it deliberately avoids an external LLM so the three backends stay byte-identical, and that does not mean Lume can only run agents that way. The docs keep the two apart; the first group is what the language actually puts in your hands.
Are the performance numbers trustworthy, and how do I check them myself?
The three speedups come from real measurements in bench() and only flow through /api/bench. curl https://lume.erishen.cn/api/bench returns the raw values; the page chart does not process them, and tests/check_coverage.py keeps items and details from drifting. The numbers themselves are historical measurements reflecting the conditions of that benchmark run.
Leave a reply