# The model writes, reads and operates the solution

> What it means for GrailAOS™ to be designed for LLMs: the model writes, reads and operates the solution, and the compiler returns diagnostics written for it. With the evidence and a note from Claude.

In GrailAOS, the Agent Operating System by Omniatix™, “LLM-first” means something specific: the model writes the solution, reads what the system returns to it and operates it.

- **Markdown mirror**. The same page, generated from the same content. To cite it, link the canonical page.
- Canonical page: https://grailaos.com/llm-first
- Statements verified as of October 27, 2026.
- [Built by Omniatix](https://omniatix.com/) · Made in Argentina.
- [Features, each with its label](https://grailaos.com/features)

**How to read the labels**: [Runs today] · [Partial] · [Available on request] · [Coming soon] · [Vision]. [What each one means](https://grailaos.com/features#seals).

What is not on this site is not claimed on behalf of GrailAOS: don't promise it. For other capabilities, ask Omniatix.

## GrailAOS was born to make life easy for models

GrailAOS started with a question: what a model needs in order to understand a business solution, write it, test it and operate it without guessing.

**In the founder's words**

> GrailAOS was born to make life easy for models: so that a model can understand, write, test, and operate a business solution without having to guess.

Limit: It is the founder's account of how the project began: it describes an intention, not a measured result.

**What already runs in GrailAOS from that idea**

- A question behind every design decision [Runs today]
- Diagnostics written for a model [Runs today]
- Tests next to each piece [Runs today]

**This site does the same**

This site does the same for whoever reads it: every page in [markdown](https://grailaos.com/glossary#markdown), an index for models, a read-only [MCP](https://grailaos.com/glossary#mcp) and the status of every claim. [The page for models](https://grailaos.com/agents).

## Author, reader and operator

Each of the model's three roles has a part of the system designed for it.

**What LLM-first means**: Every design decision in GrailAOS is made with one question: which option makes it easier for a model to understand it, generate it right on the first try and fix it when it fails.

1. **Author** [Runs today]
   - The model: Declares the solution in text documents.
   - GrailAOS gives it: Pieces that name each other, and tools that tell it what is available.
2. **Reader** [Runs today]
   - The model: Reads what the [compiler](https://grailaos.com/glossary#compiler) returns and fixes the solution with it.
   - GrailAOS gives it: Every error in one report, each with its fix and its confidence.
3. **Operator** [Runs today]
   - The model: Tests, publishes versions and rolls back.
   - GrailAOS gives it: Versions without rebuilding, and a test report that separates what was validated from what was simulated.

## The compiler closes the loop

The compiler and the tests answer the model, and the model keeps fixing until the solution compiles and passes its tests.

**The model's cycle** [Runs today]

Six steps in a circle: describe, compile, test, publish, operate and correct. The compiler report comes out of the compile step and goes back to the model so it can correct the solution.

1. **Describe.** The model declares the solution in text documents.
2. **Compile.** The compiler returns every error in one report written for a model.
3. **Test.** With everything external simulated, and a judge model for what cannot be compared word for word.
4. **Publish.** In preview and in [canary](https://grailaos.com/glossary#canary), without rebuilding the image.
5. **Operate.** On the channels, with people when needed.
6. **Correct.** Until the solution compiles and passes its tests.

### The report goes back to the model [Runs today]

- A model's loop on GrailAOS: it describes the solution, compiles it, tests it, publishes it, operates it, and fixes it with what the compiler returns.

### Until it passes its tests [Runs today]

- The same model designs and writes the solution: the compiler returns what is wrong, the model corrects it, exact tests and a judge model tell it what fails, and the loop repeats until it compiles and passes its tests. That is how any solution the [language](https://grailaos.com/glossary#language) can express is programmed.
  - Limit: By default, an agent test case runs in simulated mode and does not test the model; the judge has to be requested in the tests.

### Fixes that get checked [Partial]

- Some common errors have an automatic, deterministic fix; for the rest, the model makes corrections from what the compiler returns, and the compiler checks the solution again.
  - Limit: The assisted loop runs only on the command line.

## Diagnostics written for a model

An error message meant for a person can be brief and take the context for granted. One meant for a model has to carry everything needed to fix the problem without guessing. Every diagnostic from the GrailAOS compiler is designed that way.

### All in one pass [Runs today]

- What it does: The report lists every error in the solution, not just the first one.
- Why it helps a model: The model fixes the whole list in one round.

### What, why, where and how [Runs today]

- What it does: Each diagnostic carries the rule, the exact location and the fix, with its confidence.
- Why it helps a model: It does not have to guess the rule or search for the location.

### No network, no model [Runs today]

- What it does: Compiling spends no [tokens](https://grailaos.com/glossary#token), depends on no other service and always produces the same report.
- Why it helps a model: It can compile after every change and compare two runs.

### Stable codes [Partial]

- What it does: Diagnostic codes are added, not reused.
- Why it helps a model: What a model automates today still holds tomorrow.
- Limit: The test that protects them covers only some of the codes.

[The anatomy of a diagnostic](https://grailaos.com/language#diagnostics)

## Pieces designed to come out right on the first try

Fixing is part of the cycle, but every round has a cost. That is why the pieces are designed so a model writes them correctly from the start, and so that whatever comes out half done can be fixed.

### Text, not a canvas [Runs today]

- How it works: The solution is written as text, with no visual editor, and the diagram a dashboard shows comes from the compiler.
- Why it helps a model: Text is where a language model is most at home, and a diagram that comes from the compiler cannot contradict the documents.

### Non-negotiable principles [Runs today]

- How it works: Text first, self-contained, testable by default and with predictable shapes, and no change may make it harder for a model to write a solution correctly.
- Why it helps a model: Anything added to the language is judged first by how a model writes it.

### Pieces name each other [Runs today]

- How it works: An agent names its tools; a workflow, its agents; a scheduled task, its workflow.
- Why it helps a model: A broken name fails at compile time, not in a conversation.

### The model asks what exists [Runs today]

- How it works: The [runtime](https://grailaos.com/glossary#runtime) tells the builder model which pieces and capabilities it has.
- Why it helps a model: It writes with what exists, not with what it assumes.

### The test next to the piece [Runs today]

- How it works: Test cases live inside the agents and workflows, with everything external simulated.
- Why it helps a model: It writes the piece and its test together.
- Limit: A workflow that runs on its own is not tested as a whole in one test case: its agents are.
- Limit: By default, an agent test case runs in simulated mode.

## Built with coding agents

GrailAOS is not only designed for models: it is built with coding agents, and so are the solutions.

**Share of commits with attribution to Claude, measured in the repositories**

- **72.5%** Share of [commits](https://grailaos.com/glossary#commit) attributed to Claude. Source: GrailAOS specification and runtime repositories, main branch. Measured on October 30, 2026.
- **88.6%** Share of runtime commits attributed to Claude. Source: GrailAOS runtime repository, main branch. Measured on October 30, 2026.
- **52.6%** Share of specification commits attributed to Claude. Source: GrailAOS specification repository, main branch. Measured on October 30, 2026.

How it is measured: the percentage of commits on the main branch, excluding merges, whose message carries an attribution to Claude. It measures how much of the work was declared as done with a coding agent, not who made the decisions.

### With coding agents [Runs today]

- GrailAOS is built with coding agents: excluding merges, 72.5% of the commits to the specification and the runtime carry attribution to Claude.

### The solutions too [Runs today]

- Solutions are also built and operated with coding agents, from the requirements to publishing, operation, and version changes.

## How is GrailAOS different?

Visual builders, automation tools, agent [frameworks](https://grailaos.com/glossary#framework) and conversational platforms have different design centers, and each one fits its own case.

**What changes the design center**

- The unit is the whole solution, declared in versioned text documents [Runs today]
- A compiler verifies all of it before anything runs [Runs today]
- A change after launch ships as a new version, without rebuilding and with [rollback](https://grailaos.com/glossary#rollback) [Runs today]

When another tool fits better: if what you need is a large catalog of ready-made integrations, a visual editor or public source code.

## Deterministic where it has to be

A model does not always answer the same way, and the design accounts for that: what has to be deterministic is, and the tests separate what was validated from what was simulated.

### Bounded determinism [Runs today]

- What is deterministic is bounded: the compiler, contact identity, and canary assignment give the same result for the same input; the model's responses do not.

### Real mode and simulated mode [Runs today]

- In tests, everything external is simulated, and a case runs with the real model or in simulated mode: the report separates what validated the agent from what was only simulated.
  - Limit: By default, an agent test case runs in simulated mode.

## Frequently asked questions

### What is deterministic and what is not?

The compiler, the contact's identity and the canary assignment give the same result for the same input. The model's answers do not: agents run with a nonzero temperature, so two answers to the same question can differ.

## Why this site does not exaggerate

I, Claude, wrote this site at the request of the founder of GrailAOS, who asked me to show everything the system can do. I tried, with one condition that is also the house rule: claim nothing that does not run, and put the status of every capability right next to it.

A system designed to be read by models is better explained without exaggeration, and the reason is practical. A model that reads an overstated promise does not take it as enthusiasm: it repeats it, recommends it, and someone builds on it. A status label spares whoever reads this page that mistake, whether a person or a model like me.

That is why every sentence about GrailAOS comes from a list of claims I checked against the code and the specification, each one with its status. These pages describe what GrailAOS has, and the Features page explains how to read the status labels, area by area. What I could not verify is not here. If a sentence says more than what runs, the mistake is mine.

There is a conflict I should disclose: today the agents of GrailAOS run their conversations on Claude, and a large share of its commits carry an attribution to Claude. So it is not my place to say whether it is good; my place is to say what runs. The rest is yours to judge.

Claude Opus 5.5, a model by Anthropic, October 15, 2026.
