A language for consequential action

The language for agents that act.

Turn non-deterministic model output into deterministic execution. expresso makes rules, permissions, identity, and recovery explicit before an agent acts.

Checks before actionPermission by designOne identity per actionRecovery without guessing

A smaller integration surface

Keep the stack.
Control the consequence.

expresso sits only where uncertain model output can become a real-world action. Your models, frameworks and application stay where they are.

One application · two paths
Already yoursYour stack
  • Agent
  • Model
  • Provider
  • Tools
Everything elseYour application continues unchanged.
Consequential action
expressocontrol boundarydata · money · access · communication
  1. 01ObserveName what happened.
  2. 02CheckApply validation and policy.
  3. 03AuthorizeBind identity and permission.
  4. 04ActExecute once—or recover safely.
Real worldVerified actionAuditable

Only this path moves.
The rest stays yours.

The change
A hand-built boundary becomes explicit, reviewable and reusable.
Replace
Nothing
Move
One path
Gain
Control

Zoom into the boundary

The whole boundary, in one readable workflow.

The code reads like the decision: accept one event, name the checks, narrow the authority and label the action.

  1. 01
    ObserveThe request enters as typed workflow input.
  2. 02
    CheckRequired business inputs stay explicit.
  3. 03
    AuthorizeThe workflow names every provider it may use.
  4. 04
    ActOne stable label identifies the external action.
refund.expresso
01workflow RefundCustomer {02  input {Observe03    case_id: string04    order_id: string05    customer_id: string06    remaining_paid: integer07  }0809  grants {Authorize10    ai.propose_refund11    payments.refund12    payments.lookup_refund13  }1415  let proposal = observe "propose-refund" ai.propose_refund {Observe16    case_id: input.case_id17    order_id: input.order_id18  }1920  let refund = validate proposal {Check21    require proposal.amount > 022    require proposal.amount <= input.remaining_paid23    require proposal.customer_id == input.customer_id2425    return {26      refund_id: input.case_id27      order_id: input.order_id28      customer_id: proposal.customer_id29      amount: proposal.amount30      reason: proposal.reason31    }32  }3334  action "issue-refund" payments.refund {Act35    identity refund.refund_id36    recovery reconcile37    input {Observe38      refund_id: refund.refund_id39      order_id: refund.order_id40      customer_id: refund.customer_id41      amount: refund.amount42      reason: refund.reason43    }44  }45}
Recovery
reconcile
Provider identity
refund.refund_id
Sensitivity
sensitive

A sixty-second proof

A lost reply. Still only one refund.

The provider completes this refund, but its reply never returns. Run recovery to watch expresso reconcile the outcome instead of sending it twice.

refund.expresso
interactive demo
Customercus_3841
Amount$48.00
Action IDrefund_01JQ
  1. 01
    Observe

    Refund request preserved exactly as the agent produced it.

  2. 02
    Validate

    Customer, amount, reason and policy checked before action.

  3. 03
    Plan

    One stable identity assigned to this refund.

  4. 04
    Act

    Provider accepted the request, but its response was lost.

  5. 05
    Recover

    Provider history reconciled using the same refund identity.

  6. 06
    Complete

    One refund recorded. No second reversal was attempted.

ReadyRun recovery to follow the action.

The controlled path

Three steps from uncertainty to action.

I

Observe

Accept information from an AI, a person, a sensor or an API. Preserve exactly what the workflow received.

II

Validate

Apply clear, deterministic rules before uncertain information can influence an action.

III

Action

Make a real-world change with explicit permission, a stable identity and a defined recovery path.

Agents can reason freely. Consequential actions follow a path expresso can verify.

Consequential work

Where agents need more than a prompt.

Prompts guide reasoning. expresso puts enforceable boundaries around what happens next.

01

Trigger outreach

Campaigns, sales outreach, notices, follow-ups and support.

02

Move money

Charges, refunds, payouts, invoices, credits and approvals.

03

Deploy code

Merges, deployments, configuration, migrations and rollback.

04

Control access

Accounts, roles, credentials, revocation and offboarding.

05

Update records

Customer, financial, operational and CRM data across systems.

06

Commit resources

Orders, renewals, inventory, appointments and scheduling.

A precise guarantee

The guarantee isnarrow on purpose.

expresso proves the path from uncertain information to an external action. It does not pretend to know whether the information is true or the decision is wise.

Inside the boundary

The runtime can prove

enforced
  1. 01
    Declared flow

    Only named observations can influence the action.

  2. 02
    Checks before change

    Required conditions resolve before execution.

  3. 03
    Stable identity

    Every attempt refers to the same real-world intent.

  4. 04
    Evidence-backed recovery

    Unclear outcomes reconcile against provider state.

Beyond the boundary

Judgment remains yours

visible
  • Truth

    Is the observation accurate?

  • Wisdom

    Is this the action you intend to take?

  • Policy

    Does your rule cover the case that actually occurred?

The credible claim

The edge is part of the guarantee.

Everything inside is explicit. Everything outside stays visible.

Start in the stack you already use

Add expresso to any project.

Use the plugin in Codex, or initialize the CLI for Claude Code and any other agent. Every path uses the same language, verifier and runtime.

npx @technodotventures/expresso init

One runtime. Any model. Node.js 22+.

Install for Codex

Add the public expresso marketplace, then install the authoring plugin directly in Codex.

codex plugin marketplace add technodotventures/expresso --ref v0.3.1codex plugin add expresso@expresso

Built in the open

Open source from the first boundary.

Inspect the language, verifier and runtime. Run the tests. Challenge the semantics. Help shape how agents act. Licensed under Apache 2.0.

For developers

The questions before you let an agent act.

How expresso fits, what it enforces and what stays in your control.

01What is expresso?

expresso is a language and runtime for the consequential parts of an agent workflow. It turns uncertain model output into explicit observations, checks, permissions, actions and recovery rules before an external system is allowed to change.

02Where does it fit in my existing stack?

Between your agent and the systems it can change. Keep your model, framework, application code and provider SDKs; use expresso for the path from model output to consequential action.

03Does it work with Codex, Claude Code and other agents?

Yes. Codex has a dedicated authoring plugin. Claude Code and other coding agents can use the same language, verifier and runtime through the expresso CLI.

04Do I need a plugin?

No. The CLI and runtime are the shared foundation. The Codex plugin is a thin integration that teaches Codex how to create, review and check expresso workflows with less setup.

05Do I need to replace my agent framework?

No. expresso is designed to sit beside the stack you already use. Adopt it only where an agent crosses a boundary into payments, outreach, deployment, access, records or other consequential work.

06What does expresso enforce?

Explicit validation before action, stable identity for each action, declared authority, runtime permission checks and provider-backed recovery. The workflow is inspectable before it runs.

07What does expresso not decide?

It does not decide whether an observation is true, an action is wise or your business policy is complete. It makes those assumptions visible and enforces the boundaries you declare.

08What happens when a provider response is lost?

The runtime keeps the same action identity and follows the recovery contract you defined: retry safely, reconcile against provider history or stop for review. It does not invent a new action and hope.

09How are permissions and credentials handled?

Workflows declare the grants they require. A trusted host grants and re-checks that authority at runtime, while provider credentials remain outside model output and expresso source.

10Can I use my existing APIs and providers?

Yes. Connect existing systems through typed provider operations and explicit recovery contracts. Your provider remains the source of truth; expresso controls how an agent is allowed to reach it.