Skip to main content
The Capsule is the layer between expensive thinking and cheap execution. It is what makes Orkestral different from an AI chat or an editor: the premium model does not execute everything, it compiles each task into a Capsule, and the local model (the Forge) executes that Capsule with far higher fidelity than it would alone. The internal protocol that defines this format is called OEP (Orkestral Execution Protocol).

​
The problem it solves

A small local model is fast and free, but on its own it:
  • cannot understand a large task;
  • needs very well filtered context;
  • needs small, crystal clear instructions.
A premium model understands everything, but is expensive to run on every file. The Capsule combines the best of both: the premium spends tokens once to compile; the local model executes cheaply and as many times as needed.

​
What is inside a Capsule

A Capsule is OPERATIONAL compression, not a summary. Instead of repeated prose, it carries structure the executor consumes without re-inferring:

Distilled intent

The goal in one line, plus the canonical terms of the task.

Exact target

The file and the region (symbol or lines) to touch, not the whole file.

Verifiable contract

The done criterion as predicates the machine checks (symbol present, imports intact, no shrinkage).

Scope

What it may and may not touch (anti out of scope), enforced for real.

Project patterns

Your repository’s conventions, distilled into short rules.

Learned pitfalls

What already went wrong in this repository, so the model does not repeat it.

​
The cycle: understand, compact, execute, validate, learn

1

Understands

The premium model reads the request and the project, helped by the knowledge base.
2

Compacts

It distills everything into a Capsule: target, contract, patterns, pitfalls and one accepted-edit exemplar.
3

Executes

The Forge applies the change locally, fast and with zero API cost.
4

Validates

The contract is checked for real. For frontend, the build runs. See proven delivery.
5

Learns

Every failure becomes a pitfall and every win becomes an exemplar. The next Capsule comes out better on your project.

​
How it learns from your project

The Capsule is fed by two memories that grow with every run:
  • RAG of wins. Edits that passed become exemplars; the next similar task gets the right example.
  • RAG of errors (pitfalls). Each failure (anchor that did not match, dropped import, broken build) becomes a short “when, avoid, because” rule. The same error converges instead of being re-discovered.
By design, the Capsule’s core is deterministic: it is assembled from signals the pipeline already produces, so it delivers value even before the premium refines the free-text fields. The premium raises quality, it does not create the structure.

​
How you use it

You do not build the Capsule by hand. The flow is automatic:
  1. You chat and describe what you want.
  2. The orchestrator writes a rich plan in the knowledge base and points the issue at it.
  3. At execution time, the system compiles the Capsule from the plan, the code and the error memory.
  4. You follow it in the logs and savings: how much the Forge resolved locally and how much premium it avoided.

​
See also

The Forge

The local model that executes the Capsule for free.

Proven delivery

The gates that confirm the Capsule was actually fulfilled.