Core concepts.
The model, the agent, and the action layer.
The pieces
Matilda is a model, an agent, and the action layer between them. Name the three and the rest of the product is just how they connect.
Matilda is Maincode's assistant, served from Melbourne. It reads your code, reasons about it, and produces edits and commands. It never touches your machine on its own.
The coding agent that drives the model in a loop: read the repo, plan, act, check the result, repeat until the task is done or it needs you.
The typed tools the agent is allowed to call: read a file, write an edit, run a shell command, search the tree. Every call is visible, and in the default approval mode every write waits for you.
The working set the model reasons over: the files in play, the conversation so far, and any notes the agent has kept about your project.
How a task flows through
A request you type becomes a sequence of tool calls before a single line of your code changes.
- Read. The agent pulls the files it needs from the working tree into context. It reads them in place; it does not copy them.
- Plan. The model proposes a sequence of edits and commands, and shows you that plan for anything non-trivial.
- Act. Each step runs through the action layer. Edits appear as diffs; commands appear as the exact line to be run.
- Verify. The agent runs your tests or build, reads the output, and either moves on or corrects course.
The model, in one paragraph
Matilda is a single model with a long context window, not a router over smaller ones. Maincode serves it from infrastructure we operate in Melbourne. You give it the problem and the relevant slice of your codebase; it returns edits, commands, and an explanation of why. It has no standing access to your machine. The action layer does, and in the default mode the agent only reaches it with your approval. That separation is the whole safety story: the model can be wrong, but it cannot act on being wrong without a human or an explicit permission in the loop.
The point isn't a model that writes code. It's an agent that can change a real repository and still be safe to leave running.
What we deliberately don't do
Matilda Code doesn't run as a background service, doesn't watch your filesystem, and doesn't phone home with your source. It's a foreground process you start, that acts only while you're there, and that stops when you close it. If you ever wonder what it's doing when you're not looking, the answer is nothing; it isn't running.
This is the design decision teams question first and rely on most: the agent has no life of its own outside the session you started.
Where to go next
- Headless and CI, running Matilda Code from scripts and pipelines.
- Context and memory, what the agent keeps and what it forgets.
- How an agent run works, the loop and the five approval modes in detail.