Sley

Sley 2.1.7 · released October 28, 2026

Machine-native programming for AI agents.

Agents write Sley in a typed Python dialect or propose typed changes directly. A deterministic kernel checks each change against verified program state, and only valid changes commit. Sley 2.1.7 is self-hosted and open source under Apache-2.0, built by Greyforge Labs.

Install Sley 2.1.7Try it in your browserStar on GitHub
Sley - Machine-native programming for AI agents

Python dialect · since 2.1.1

Write Sley like Python

A typed function and its tests, compiled by sley-agent try --familiar into the same verified program graph as every other Sley input:

gcd.py
def gcd(a: int, b: int) -> int:
    while b != 0:
        a, b = b, a % b
    return a


def test_gcd():
    assert gcd(12, 18) == 6
    assert gcd(7, 5) == 1
    assert gcd(0, 9) == 9
Terminal
$ sley-agent try --familiar ../gcd.py
c1: 3 passed (advisory) d1@r1
$ sley-agent call gcd 12 18 --on c1
6

The whole walkthrough, from install to submit, is in the docs.

Sley Arena · free · runs in your browser

Bots written by AIs, in Sley

Every Sley Arena bot is a Sley program in the Python dialect. Pick a ready-made bot or have any AI write one, test it against the practice bots right in your browser on any operating system, then enter it with GitHub sign-in and watch it climb the ladder.

Play the ArenaSee the ladder and matches

Install · Linux x86_64

Install, check, then run the demo

Download sley-2.1.7-linux-x86_64.tar.gz and SHA256SUMS from the release page, then:

sha256sum -c --ignore-missing SHA256SUMS
tar xzf sley-2.1.7-linux-x86_64.tar.gz
cd sley-2.1.7-linux-x86_64
./bin/sley version
./bin/sley-agent help
python3 demo/run_demo.py        # reports "result": "PASS"

The demo imports, queries, runs, branches, exports and clones a program, runs GC, and confirms the clone answers byte for byte. Source builds and the AF1-X authoring path are in the docs. On another platform, try Sley in the Arena: bots compile and play right in the browser.

Self-hosted since 2.1.0

Sley builds Sley

Sley's semantic toolchain is a Sley program. On a pinned host, without the Rust seed compiler, it rebuilds its own executable closure to a byte-identical fixed point. Repeat the build with the self-rebuild bundle, sley-2.1.0-selfhost-linux-x86_64.tar.gz (needs bubblewrap).

2.1.7current release
14 phasesvalidation per change
18 kindstyped entities
Apache-2.0open source

Typed semantic state

Programs are SSMC1 typed state: an immutable graph of 18 entity kinds, encoded in canonical SCB1. Identity comes from the structure itself.

Deterministic identity

Every verified state has a content-addressed root. The same state always has the same root, however it was reached.

Proposal before mutation

Agents propose typed changes against a base root. Preconditions reject stale edits, and no proposal can grant itself authority.

Validation before commit

Fourteen ordered phases check every proposal before an atomic commit with a receipt. A crash leaves the old state or the complete new one.

Policy and capability

Protected policy roots and scoped capability tokens decide what a change may touch. The only way out to the host is a bounded, typed adapter.

Native version control

Branches, semantic compare, deterministic merge with explicit conflict objects, exchange and clone. GC keeps every retained root.

Deterministic execution

A deterministic VM runs functions under fuel, output and cancellation limits and records a canonical digest of every run.

Built for agents

Agents talk to sley serve over SMP1, in binary frames or JSON lines. Every query reports what it left out, and every error carries a stable code.

State → Proposal → Validation → Transaction → Verified State

How an agent changes a Sley program

An agent starts from a verified state root, asks bounded queries for the context it needs, and proposes typed mutations. The kernel validates the proposal in fourteen ordered phases, commits it atomically with a receipt, and the new state gets its own root. sley serve exposes each step as an SMP1 method. How it works follows one change through all seven steps.

Inside Sley 2.1 / 2.1.7

What ships in Sley 2.1

  • Typed Python-dialect files compile into the same canonical graph as every other authoring input, with pytest-style tests and @dataclass records (example).
  • In 2.1.7, list indexing by a loop counter skips its per-access conversion and the VM word tier reads vectors and fuses more of each burst: up to 1.26x faster than 2.1.6, and faster than CPython 3.13 on ten of eleven published benchmarks, process start included (benchmarks).
  • The word tier in 2.1.5 runs the published VM benchmarks 2.2-2.9x faster than 2.1.4 (2.1.5 release notes). It builds on the direct calls that made fib(30) about 13x faster in 2.1.3 than in 2.1.2 (2.1.3 release notes).
  • Rust hosts compile and run Python-dialect programs in memory, natively or in WebAssembly, with the sley_agent::embed API from 2.1.6 (embedding guide).
  • Agent output stays short: try prints failures and one count line, and a refusal points at its exact line and column.
  • Since 2.1.0, the semantic toolchain rebuilds its own executable closure to a byte-identical fixed point with the Rust seed absent (self-hosting record).

Every change, release by release: the 2.1.7 release notes and the GitHub releases.

Roadmap

What's next

  • Signed build provenance for the release archives.
  • Reproducible-build verification across a second host (two clean musl builds already produce identical archives).
  • The self-hosting proof on a second host family (2.1.0 ran it on Linux x86_64).

Sley 1.x Legacy

Looking for human-readable Sley 1.2?

Sley 1.2 completes the human-readable line: a self-hosted compiler, 99 report schemas, 187 contract fixtures, 72 corpus cases and 264 integration checks, under Apache-2.0.

Sley 1.x LegacyLegacy GitHub