Documentation

Full language reference, compiler architecture, and quick start guides.

SkCC

Skills Compiler — compile agent skills into optimized runtime modules.

EvoBench

Agent benchmark suite — measure and compare autonomous agent performance.

EpiContext

Evolutionary context management — genetic algorithms for optimal context windows.

Nexa Organization

GitHub organization with all Nexa projects and repositories.

Author

Owen — creator of the Nexa language and Harness Native methodology.

v3.0.0 — Open Programs

Programs that stay
open to change.

Write goals and contracts in .nx. People and models collaborate through the compiler. Programs retain their implementations, evidence and revisions as requirements change.

Python 3.10+ · Linux/macOS · Docker/OCI for execution.

python -m pip install https://github.com/Nexa-Language/Nexa/releases/download/v3.0.0/nexa_lang-3.0.0-py3-none-any.whl

Install this GitHub wheel directly. The PyPI name nexa-lang belongs to another project. Installation guide →

answer.nx · an open goal
language "3.0"
program Answer {
    goal answer() -> Int {
        intent "Return the number 42"
        ensure checks.answer
        implementation open
    }
}

nexa check answer.nx --json checks the contract offline. A configured provider and frozen check can resolve the open implementation. Start with a complete example →

Goals, code and evidence.
One evolving program.

Open Programs extends the Harness Native foundation: the language owns what a program must achieve, the conditions under which it is accepted, and how its next revision becomes active.

Compilation includes resolution

Typed open goals can be implemented by a person or resolved by a model. The compiler enforces a shared budget and executes candidates and checks in OCI.

Revisions persist beyond a run

Activities stay pinned to immutable revisions. Checkpoints admit new versions; durable events and process leases support restart and conflict detection.

Evidence has a current context

Deterministic checks, model reviews and human decisions remain separate records. Changed inputs, policies or dependencies create new verification obligations.

Exact authority for workspace edits

Maintenance produces a reviewable patch. A grant binds its baseline, paths and evidence; a journal and retained originals protect edits during recovery.

Reuse carries its conditions

Local implementation capsules retain provenance, license, dependencies and evidence. A receiving task checks compatibility and revalidates under its current inputs.

The compiler can improve with you

The author protocol supports clarification and diagnostics. A diagnostic advice pass is selected after frozen tests, locked bootstrap and explicit approval.

Start with a complete goal. Then open it.

Check a typed program offline. Build it with a configured execution environment, then replay its locked artifact without asking a model to generate it again.

answer.nx · explicit implementation
language "3.0"
program Answer {
    goal answer() -> Int {
        intent "Return 42"
        implementation value 42
    }
}

nexa check answer.nx --json validates the source without Docker or credentials. The explicit value is the implementation; open goals let a configured model propose one.

Build and replay · from a source checkout
nexa build answer.nx \
  --environment examples/open_programs/offline.json \
  --state .nexa/demo.db --json

nexa build answer.nx \
  --environment examples/open_programs/offline.json \
  --state .nexa/demo.db --locked --json

Start Docker and pull the pinned image listed in the guide. Keep both the lock file and state database. Locked builds revalidate current evidence and make zero model requests. Execution and maintenance guide →

From an open goal to an accepted revision

The deterministic kernel owns identity, policy and lifecycle. Models propose implementations and reviews; isolated execution supplies evidence. Python is the 3.0 reference implementation.

.nx Source

Types + goals

→

Compiler + Model

Clarify + resolve

→

OCI Executor

Fixed checks

→

Evidence

Context + policy

→

Revision

Admit + checkpoint

Published scope. Reproducible checks.

139
Open Programs contract tests
360
Real-model experiment stages
67
Examples checked
3.10+
Supported Python

Validation covers current evidence, authorization, concurrent edits, crash recovery and locked replay. CI runs Python 3.10, 3.12 and 3.14 on Linux with real OCI execution. Five unconfigured PostgreSQL tests are skipped; timing benchmarks run separately.

The six-stage Aliyun demonstration completed with 11 model requests. In fixed synthetic tasks, Open Programs accepted 73/90 stages and the adapted 2.4 baseline 70/90. The report includes failures, token totals and the baseline-schema correction. Read the evidence →

Make completion explicit

A versioned language boundary

language "3.0" selects Open Programs. Existing Agent and flow sources retain their 2.4 entry point. Legacy state exports into an inert archive with an explicit conversion report.

Recovery respects side effects

Unknown non-idempotent effects require reconciliation. Patch application preserves original files in recovery directories. Cross-file updates use a journal and require storage for retained originals.

Isolation is an execution property

Open Programs candidates run as non-root in offline, resource-limited OCI containers without host mounts or credentials. Legacy Python tools keep their documented host semantics; Rust retains its 2.4 subset.

Read the migration guide and supported scope →

Give your program a goal worth maintaining

Download 3.0.0, start with a typed goal, and keep the evidence behind every accepted revision.