How it runs

The interface is fluid, and an AI is running the application.

Two things are different about an Agentic Interpreted Application, and both take a minute to get used to. Nobody designed its screens. And the thing deciding what happens when you press a button is a language model, held to your model by an engine that never lets it write.

Open Amy How it is built

Static software is built once, for everyone. A fluid interface is composed each turn, for what is in front of you.

Static interfaces

Every screen you have ever used was decided before you arrived.

Someone chose the columns, the form, the order of the buttons, months before you needed them, for a user who is not you, with a data set that is not yours. That decision was compiled into code, and code does not change when the situation does.

: Static interface; Fluid interface
Who decides what you see: A designer and a developer, once, for every user.; Amy, at this turn, from the model, the rows, and what you are doing.
One record: The same detail page for every record, empty fields included.; The record’s real fields, its references resolved to names, the actions the model grants on it.
Many records: A table, because a table was built.; A table, a board when a status field asks for one, a timeline when dates do, figures when the question is “how many”.
A new field: A ticket, a sprint, a release.; Approve the change to the model. It is in the next turn.
A new operation: Backend, frontend, tests, deploy.; Describe it. Approve it. Press it.
A decision the software cannot make: An error message, or a field that accepts anything.; A question, asked in the turn, with the rows it concerns in view.
Moving between views: A page load. The old screen is gone; the new one is unrelated.; The current view dissolves into the next. Motion says a turn ended and what carried over.

Fluid interfaces

A turn is composed, streamed, and gone when you move on.

Each time you open the App or act in it, Amy composes one turn: what deserves attention, what to focus on, where you can go, and whether there is something to ask. It streams in as it is decided, so the interface arrives the way a thought does.

Attention

One line about what matters now: the tickets past due, the request waiting for a decision, the run that finished. Drawn from the rows, not from a dashboard someone laid out.

Focus

The thing to look at: a set of rows, one record, a board, a timeline, figures, or a judgment the model is asked to make. The shape follows the data and the question.

Moves and asks

Where you can go from here, and what Amy needs from you before an operation can run. A move is an operation or a view the model defines. Nothing is invented.

What stays still while everything moves

Fluid does not mean unpredictable. Under every turn, the same things are always there.

Every record has a working surface: search across resolved labels, filters, sort, paging.
The vocabulary is the model’s. A Ticket is called a Ticket in the model, the Config, and the turn.
Row actions come only from operations the model defines on that record.
The ask bar at the bottom takes a plain sentence and turns it into a move or an operation.

One turn in the Amy App: a record opened as a page, with the moves that lead to the next turn.

An AI runs it

What it means that a language model is running your application.

Not that the AI writes to your data. It never does. When you run an operation, the model reads the approved contract and the rows in front of it, and returns a plan: which rows to create, change, or remove, with which values, and a result. The engine, deterministic and yours, checks that plan against the model and commits it in one go, or refuses it and says why.

: The AI interprets; The engine guarantees
The contract: Reads the operation as written: its inputs, what it expects, what it ensures, what it decides, who may call it.; Verifies the plan writes only records the operation is allowed to change.
The rows: Sees the current rows of every record involved, and the related rows one step away.; Every row the plan touches must exist, unchanged since the model saw it. A change meanwhile is a conflict, never a lost write.
The values: Fills fields the contract lets it judge: an urgency, an area, a classification, a computed total.; Types, required fields, enumerations, and references are checked. Values you typed are stored as you typed them.
The decision: Picks exactly one of the outcomes the contract names, and may write nothing when the outcome rejects.; An outcome the contract does not name is refused.
The caller: Knows who is acting: you, as the person the model names, so “the assignee” and “the caller” mean someone.; Records who acted, on which rows, in a journal you can read.
The commit: Proposes. Only proposes.; Applies all of it or none of it, journals the plan, and marks on every row which fields the model chose.

The AI never writes. The engine does.

What it does not mean

Four things people assume, and why each is wrong.

Not a chatbot

You use an application, not a conversation.

Tables, records, boards, forms, buttons. The ask bar is there when a sentence is faster than a click. The interface is the point; the model is behind it.

Not autopilot

Nothing runs that you did not approve.

The model is a plan you read and accepted, change by change. The AI runs that plan. It cannot add an operation, a record, or a rule on its own.

Not made-up data

A hallucination has nowhere to land.

Every value the model proposes passes the record’s schema, the contract’s checks, and the reference gates before it is stored. What does not fit is refused with the reason.

Not a black box

Every call is on the record.

The model log shows each prompt, each reply, the time it took, the tokens, and the estimated cost. Every row carries which of its fields a model chose and under which operation.

The trade

What you give, and what you get.

Time: An operation that needs judgment takes a model call: seconds, not milliseconds. Operations the engine can prove run instantly with no call at all.
Cost: Every judgment and every composed turn is metered on a model you choose and pay for. The App shows the running estimate. Nothing is hidden in a subscription.
Rules: The engine guarantees exactly what the model says. A rule that is not in the model is not enforced. Put it in the model; that is where it belongs.
Outside: Payments, mail, a warehouse system: the model names the capability, and the Config says who fulfils it, an agent or a real system.
You get: An application that exists the moment the model is approved, changes when the model changes, and never had a frontend, a backend, or a deploy.

How it is built When you want code instead

Open the App

Amy doesn’t write your application. Amy runs it.

Open Amy