Skip to content

Alpha, private

Give agents instructions, not infrastructure

Rein is a strict, TypeScript-like language for agent decision flows. Write each decision as a small function, one file each. The agent answers the questions, then follows the pointers to its next step.

Request early accessDocs
yesnoDecisionYes or no?Pick oneInstructionTemplateNext decision

Agent systems turn into machines

Agent frameworks ask you to build the machine. You define graphs, nodes, edges, shared state and retry logic. The instructions end up spread across the wiring.

Rein does not build a harness or a graph. It gives the agent instructions for the decision it faces now.

A dark diagram of square nodes joined by many lines, a tangled graph. The caption reads: Frameworks make you build the machine.
decisiondecisioninstruction

Rein flips it

You do not wire the agent. You write what it should decide, and what it should do for each answer.

Four ideas make a flow

  1. A stack of rounded cards, the front one outlined in teal. The caption reads: One decision, one function, one file.

    1. One decision, one file

    Each decision is a small function. Each function sits in its own file and starts with a description of what it decides.

  2. A decision card sends three question chips to one point, which leads to three answer options with one ticked. The caption reads: Inputs are questions the agent answers.

    2. Inputs are questions

    The inputs are questions the agent answers from what it sees. Each one is a yes or no, or one of a few options.

  3. yesnoDecisionYes or no?Pick a caseInstructionPointerTemplate

    3. Two moves in the body

    The body branches on an answer, or picks one case from a fixed set. Every case is written out. There are no loops, by design, for now.

  4. A decision card leads to an instruction bubble, and through a teal arrow to the next card. The caption reads: Every path ends in one of two things.

    4. Every path ends in one of two things

    An instruction, written out or built from a template such as a delegated task. Or a pointer to the next function.

Start at main. Answer. Follow the pointers.

Every project has a main function. It is the agent's entry point. The agent answers only the questions on its path, and follows each pointer until it reaches an instruction.

Four cards in a row, each with question chips above it, linked by a teal line that ends in an instruction. The caption reads: Start at main. Answer. Follow the pointers.

A checker guards every flow

The checker reads your functions and reports gaps. It catches these three problems before a flow goes to an agent.

  • Every case is handled

    A new option without a case fails the check. Nothing falls back to a silent default.

  • Every path returns

    A path that ends without an instruction or a pointer fails the check.

  • Every pointer is real

    A pointer to a function that does not exist fails the check.

Four lines, each ending in a teal check mark, beside an editor-style window with a wavy teal underline. The caption reads: Checked as you type.

Editor support

The language server shows these problems as you type. Editor support starts with VS Code.

Watch the concept

A concept video of about 70 seconds. It shows the four ideas and one flow.

Concept video coming soon.

Alpha notice

Rein is alpha and private

Rein is a proof of concept. Syntax, tools and behavior can still change. Request early access by email, and tell us which decision flow you want to build.

Request early accessDocs

Use cases

Each page shows one flow, in concept terms.