Watch the compiler
prove it.
Write a few rules, expresso serve it, and point a webhook at it. For each event it makes a typed AI judgment and fires a real action — files the ticket, pages on-call, hits your API.
The catch every other framework misses: that action lands exactly once — across a retry, a restart, even a kill -9 mid-send — and the whole run replays for your auditor. The compiler proves it, because the boundary between "guaranteed" and "AI guess" is a type system.
Agents just got write-access to your company.
And today's agents are nondeterministic glue. They double-act. You can't reproduce why they did something. You can't audit them. So no one dares leave them running on real work.
Acts twice
A retry or a crash fires the same action again. Now there are two tasks, two emails, two charges.
Can't be explained
"Why did the agent do that?" There's no record you can re-run to find out.
Can't be trusted
No boundary between what's guaranteed and what's a guess — so it stays off, or human-watched.
The missing piece isn't intelligence — it's a boundary you can prove: what's guaranteed versus what's left to AI, and a promise that every action happens exactly once. That boundary didn't need to exist until agents started acting. Now it's everything.
Watch an agent join the room
A real agent listens to a live conversation on the left and acts on it on the right — making tasks, taking notes, replying. The colored bar marks which steps are 100% predictable (green) and which are AI judgment (purple). Then hit Replay to prove it does the exact same thing, every time.
PURE ⊑ MODEL ⊑ WORLD. Model leaves (~"…", summarize, typed leaf calls) are journaled; Replay re-derives into a fresh world and compares the effect set bit-for-bit against the original, with the model port poisoned to throw on any journal miss — so "never re-called" is enforced, not asserted. See SPEC.md for the grammar, small-step semantics, and theorems.
What's guaranteed vs. AI (the determinism boundary)
Show technical trace
Exactly-once, even on a retry
A redelivered event is a visible no-op. One spoken order is one action — never a phantom duplicate, a double page, or a double payment.
Replay the day, prove the decision
Re-run any session bit-for-bit with zero model re-calls. The recording is the audit — not a reconstruction you have to trust.
It physically can't go rogue
Capabilities are declared in source and checked before anything runs. An action it wasn't granted can't even be expressed — let alone executed.
The language is the easy part. The runtime is the moat.
Every real-world action binds to a runtime that already owns the room — the live transcript, who's speaking, who's present, and capability-scoped ports for tasks, notes, and voice, backed by an exactly-once ledger. A framework built on someone else's APIs can't make the replay or exactly-once guarantee, because it doesn't own those ports. Coffee is years of that runtime, already built — Expresso is the open language on top of it.
Why it's a real language, not a config
You don't configure Expresso — you write plain rules: when someone says X, do Y. Predictable by default; AI only where you explicitly ask. That makes it a language (grammar, types, semantics) in the lineage of SQL and HCL — with one idea they don't have: the type system tells you, and proves, exactly where the AI is.
The determinism boundary is a type
Every line is graded automatically. Two markers introduce AI; everything else is compiled, total, and replayable.
/regex/matching- triggers, routing, presence
- capability checks
- memory, control flow, text
~"intent"a judgment callsummarize(span)generated text- typed
leafstructured AI output
What that buys you
- T1 — an agent with no AI step is a deterministic function of the conversation.
- T2 — AI answers are recorded once and replayed, never re-called.
- T3 — every action carries an idempotency key, so replay and retries never double-act.
These are theorems the compiler emits, checked by the type system — proven in SPEC.md and exercised by a conformance suite. The clean boundary is table stakes; the runtime it binds to is the moat.
Deploy it in one command.
Zero-dependency engine + CLI. serve a program and it's a webhook-driven service: events in, real actions out, exactly-once, with an on-disk journal so it survives restarts and crashes. Don't take the claim — run the kill -9 demo.
# zero dependencies — engine + `expresso` CLI npm install https://expresso.meetcoffee.dev/expresso-lang.tgz # a 14-line agent becomes a service: expresso serve triage.expr --apply \ --config expresso.config.json --journal ./state curl -XPOST localhost:8080 -d '{"id":"i1", ...}' # → fires Slack + a task, exactly once
# the 30-second skeptic's test: bash examples/serve-demo/demo.sh # fires an incident into a downstream OUTAGE, # kill -9's the daemon mid-send, restarts, # and the receiver log proves: ✓ each action delivered EXACTLY ONCE ✓ 0 lost · 0 duplicated ✓ Idempotency-Key on every call