Simplex
Simplex is a specification for describing work that autonomous agents will perform. It captures what needs to be done and how to know when it's done, without prescribing how to do it.
Simplex is optimized for high-fidelity interpretation by large language models.
The Specification Gap
An observed trend in AI development is the creation of new programming languages optimized for LLM code generation. The premise is reasonable: LLMs make syntax errors and struggle with operator precedence, so cleaner languages with unambiguous syntax should help.
However, this is a problem that LLMs largely do not have.
LLMs are excellent at syntax. They've seen billions of lines of code in every language. What they struggle with is understanding intent, constraints, and edge cases. A new language with cleaner syntax addresses the easy part while leaving the hard part, specification, entirely in natural language prompts.
The real bottleneck lies not in code generation, but in specification: expressing what we want clearly enough for autonomous systems to act on without interactive clarification.
Five Pillars
Simplex refuses to support constructs that would allow specifications to become unwieldy. If something cannot be expressed simply, it must be decomposed into smaller pieces first. This is a feature, not a limitation. Complexity that cannot be decomposed is complexity that is not yet understood.
Simplex allows for formatting inconsistencies, typos, and notational variations. Agents interpret what you meant, not what you typed. However, the meaning itself must be unambiguous. If an agent would have to guess your intent, the specification is invalid. Sloppy notation is acceptable; vague meaning is not.
Every function requires examples. These are not illustrations; they are contracts. The examples define what correct output looks like for given inputs. An agent's work is not complete until its output is consistent with the examples.
A valid specification must be sufficient to generate working code without further clarification. This is what distinguishes Simplex from a prompting approach. There is no back-and-forth, no "what did you mean by X?" The spec must stand alone.
Simplex describes behavior and constraints, never implementation. Algorithms, data structures, and technology choices belong to agents. If a spec needs persistent storage, it says so. Whether that becomes a graph database, file system, or something else is the agent's concern. The spec neither prescribes nor cares.
What Simplex Is
Simplex is a specification for autonomous agents that describes work rather than workers, capturing what needs to be done and how to know when it's done without prescribing how to do it.
The language has no formal grammar. It uses landmarks—structural markers like FUNCTION, RULES, DONE_WHEN, and EXAMPLES—that LLMs recognize and interpret directly. Syntax is forgiving; meaning must be precise.
FUNCTION: filter_policies(policies, ids, tags) → filtered list
RULES:
- if neither ids nor tags provided, return all policies
- if only ids provided, return policies matching those IDs
- if only tags provided, return policies with at least one matching tag
- if both provided, return union of matches, deduplicated
DONE_WHEN:
- returned list contains exactly the policies matching criteria
- no duplicates in returned list
EXAMPLES:
([p1, p2, p3], none, none) → [p1, p2, p3]
([p1, p2, p3], [p1.id], none) → [p1]
([p1, p2, p3], none, [python]) → matches with tag
([p1, p2, p3], [p1.id], [python]) → union
ERRORS:
- policy ID not found → fail with "unknown policy ID: {id}"
- any unhandled condition → fail with descriptive messageWhy This Matters
Autonomous agent workflows are maturing. Agents now work for extended periods—hours or days—developing applications, iterating on solutions, evaluating versions among themselves, and producing release candidates. These kinds of workflows need instructions that are complete enough to act on yet flexible enough to allow emergent problem-solving.
Simplex is designed for this context: a human writes a specification that agents interpret, decompose, and execute autonomously. The specification serves as the contract between human intent and machine action.
Perhaps what matters most is not how LLMs write code, but how humans express what they want built. A specification designed for human authors, one that captures intent precisely enough for autonomous agents to act on, may prove more valuable than any improvements to code generation itself.
Further Reading
Specification
The complete Simplex v0.5 specification: pillars, landmarks, validation criteria, composition, and linter rules.
Examples
Simplex specifications at varying levels of complexity, from minimal functions to multi-function coordination and evolutionary specs.
Quick Start
Write your first Simplex specification in minutes. Start with a function signature and examples, then layer in rules and constraints.