Language goals

Omega Lisp is shaped by five goals. Each one constrains the design.

1. LLM calls are first-class

In most agent frameworks, an LLM call is glue code outside the language. In Omega, (effect infer.op "prompt") is an effect like any other; the result is a Meaning value with denotation, confidence, and provenance. This is not a hack on top of the language — the value model includes Meaning, OracleProc, and an OracleReq/OracleResp protocol pair.

Trade-off: the value model is bigger than a typical Lisp's. There's a Val union with 40+ variants (projects/omega-lisp/src/core/eval/values.ts:710-762) covering distributions, machines, profiles, contexts, modules, receipts, networks, contradictions, fibers, mutexes, generic registries, promises, streams, IRs, budgets, solvers, fact stores, evaluators, macro transformers, artifacts, goals, and tagged values.

2. State persists across sessions

The REPL writes a session log on every command. Closing and reopening the REPL with the same session restores bindings and history. This is enabled by the CESK evaluator: Env, Store, and the kont stack are all serializable. The implementation lives in src/core/session/ (writer, reader, jump controller, serialize/deserialize).

Trade-off: every value must be serializable. The "live" values like Fibers, Mutexes, Channels, Actors carry an id and depend on a process-local registry; they don't survive a restart cleanly.

3. Reasoning is auditable

Every LLM call produces a receipt. Every constraint violation produces an Explanation graph. Every memory of a fact carries provenance. The Profile system (core/governance/profile.ts) classifies regimes — speculative, test-certified, proof-certified — with different rules for what can be committed.

Trade-off: a lot of bookkeeping. Receipts are not free; provenance is not free. For a "just give me the answer" use case, Omega is heavier than a thin wrapper around an SDK.

4. The runtime is reflective

with-profile, make-evaluator, register-macro, ctx/snapshot, machine-step, machine-fork — the runtime exposes its own innards as values you can manipulate. You can fork a machine and explore both branches; you can install a sub-evaluator with extended primitives; you can swap profiles for a dynamic extent.

Trade-off: a beginner Lisp this is not. Reflection commits you to making more decisions explicit.

5. The language is built for tools, not chats

Omega's standard library — solve, amb, require, fixpoint, with-budget, provenance — is shaped for programmable agent workflows, not for being a chat layer. The bench is "find a fact, validate it against constraints, retry with a different strategy"; the chat surface (:ask) exists but is a thin wrapper over the same primitives.

Trade-off: as a vehicle for "talk to an LLM" Omega is overbuilt. Use a thin SDK if that's all you need.

What Omega is NOT trying to do

Be a strict R7RS or Common Lisp. It diverges where the goals require.
Be a deployment target. Omega evaluates inline in Node; there's no AOT compiler, no native binary.
Be a replacement for the Matrix runtime. Some Matrix actors embed Omega for $eval. The Matrix runtime is the bus + actor lifecycle; Omega is a programmable inference layer that can run inside one of those actors.

Language goals ​

1. LLM calls are first-class ​

2. State persists across sessions ​

3. Reasoning is auditable ​

4. The runtime is reflective ​

5. The language is built for tools, not chats ​

What Omega is NOT trying to do ​

See also ​