Sley

Human-readable. Agent-writable. Agent-readable.

Sley is a brand-new AI-native structural programming language developed by Greyforge Labs.

What It Is

Sley is a programming language where code is a typed, auditable graph first, and text is the human-readable projection of that graph.

Most languages make AI agents edit text and hope the compiler catches the damage later. Sley gives agents a native structural surface: typed shards, verified grafts, explicit authority, and traceable provenance before runtime behavior changes.

Current Status

Track	State
Name	Sley
Language	v0 prototype and canonical design memo
Compiler/runtime	Loom
Program unit	task, not function
Agent edit unit	shard moved as typed graph structure
Patch model	graft for verified patch application; splice for local subgraph surgery
Transport	ZJX for compact graph, patch, and trace envelopes
Design date	2026-05-05

A Small Sley Program

module app.hello

task main -> Text {
  bind message = "hello sley"
  return message
}

The Core Idea

Humans read clear tasks. Source is the review surface.
Agents edit typed shards. The graph is the program surface.
The Loom is a gate. Malformed, stale, type-invalid, or unauthorized grafts are rejected.
Bindings say what they are for. Use bind, state, knot, gate, veil, draft, and related forms instead of generic variables.
ZJX is native transport. Agents move graph shards, grafts, and traces without raw text or JSON bloat.

Sley + ZJX

Sley and ZJX are designed as one stack. Sley gives agents the typed program graph, shards, grafts, Loom gates, traces, and seals. ZJX is the native envelope that moves those structures through the agent/compiler loop.

Why It Exists

AI coding is already real, but the dominant interface is still text mutation. That is brittle. Sley assumes agents will write most of the code and gives them a language-level interface built for structure, authority, lifecycle, and review.

The goal is not to replace Rust, Go, Python, or TypeScript overnight. The first goal is narrower and sharper: make agent-written software mechanically inspectable before it is accepted.