Loading...
tl;dr — An agent simulates the stack. A few documents give it the shape of an application.
Start with the idea that we can describe an application as a program, some state, and the machinery that runs it.
Cast into more specific terms, we can get the following table.
Role | Mechanism | Function |
|---|---|---|
Runtime (R) | Harness | Assembles context, runs the interaction loop, mediates tools and actions. |
Interpreter (I) | LLM | Uses context to propose responses, actions, and changes. |
Program (P) | Files | Specifies goals, constraints, and behavioral guidance. |
State (S) | Files | Holds preferences, resources, records, and working memory. |
The Agent is A = (R, I, P, S). It contains both the program and the system that runs the program. The Agent is a pattern of behavior realized by the interaction of the parts. The Agent is reshaped by changes to its machinery.
In conventional software, an application's behavior is largely specified in advance through explicit rules in strict syntax.
In the model above, the intent of an application is expressed in natural language. The interpreter works out what the instructions imply in the current situation and uses available tools to turn them into behavior.
In a practical sense, it's the documents' intention that's running. Prose express the intent. Interpretation implements the behavior.
A useful application can exist without a conventional software stack. You author a few documents, let the Agent turn them into behavior.
Since the Program, State, and in some cases the Runtime, are readable and writable by the Agent, and the Interpreter is swappable, the whole stack can mutate itself simply by you talking to it.