How Multilo works

Multilo is a desktop app where AI agents work on your real documents. You open a project — a folder on your computer with your draft, your sources, and your data — and you ask for what you need in chat or by running an agent. The agent reads what it needs, edits your document, and checks its work, while you watch and steer.

This page explains what happens under the hood: the loop every agent follows, what agents can see, where your work runs, how chats and context work, the safety nets that protect your writing, and tips for working well. For step-by-step walkthroughs, see Write a research paper. For the four basic building blocks, see Core concepts.

The agent loop

When you give Multilo a task, the agent works through three phases: gather context, take action, and check the result. The phases blend together, and the agent uses tools the whole way through — reading your sources to understand the topic, editing to make changes, and re-reading to check what it wrote.

1. Gather context

   The agent reads what the task needs: your open document, the section you selected, sources from your library, files in your project, and your project rules.

2. Take action

   It does the work — rewrites a paragraph, drafts a section, inserts citations, pulls numbers from your data, or runs code to turn a file into a result.

3. Check the result

   It looks at what came back, decides whether the task is done, and if not, goes round again with what it just learned.

The loop adapts to what you ask. A question about your draft may only need the first phase. Tightening one paragraph is a single pass. The Full Draft Writer goes round many times: it researches, plans an outline, drafts section by section, and cites as it goes. The agent decides each next step from what it learned in the last one.

You are part of the loop too. You can watch an agent’s progress as it edits, stop it at any point, and send a follow-up to change direction. When an agent needs a decision, it pauses and asks you to choose instead of guessing.

Two things power the loop: models that reason and tools that act. Multilo is the layer around the model — it gives the model its tools and puts together everything the model sees.

Models

A language model is the part that reads and writes. It understands your argument, follows your structure, and works out what needs to change to reach your goal. On a big task, it breaks the work into steps and adjusts as it learns.

Multilo offers several models with different trade-offs: a fast model for quick passes, a flagship model for harder thinking such as critiquing a methodology or planning a long draft. Pick one in the model picker for each agent or run, or turn on Auto and let Multilo choose. If the model you picked can’t handle a request, Multilo sends that one turn to a capable model on your plan and tells you it did.

When this page says “the agent decides,” it is the model doing the reasoning. For the ideas behind this, read How AI models work.

Tools

Tools are what turn a model into an agent. Without tools, a model can only reply with text. With tools, it can act: read your project, edit your document, search, check sources, and run code. Each tool gives back a result, and that result feeds the next step of the loop.

The built-in tools fall into five groups:

Agents can also ask you to choose, remember facts for next time, and — from chat — hand a whole-document job to the right agent.

The agent picks which tools to use based on your request and what it finds along the way. Ask Claim Check to verify the citations in your draft, and it will:

1. read your draft and find each citation;
2. fetch the cited source;
3. compare your claim with what the source actually says;
4. mark each one as supported, weak or unrelated, or as having a stronger source in your library;
5. show you the evidence so you can judge for yourself;
6. apply the fix you accept straight into your document, in-text marker and reference together.

Each step gives the agent new information for the next one. That is the agent loop in action.

What agents can access

When you work in a project, agents can use:

• Your open document. The whole document, not just the paragraph on screen, plus anything you have selected.
• Your project folder. Drafts, notes, data, and folders of results — anything you keep in the project. Files you @-mention or attach in chat come in too.
• Your library. The references, PDFs, and notes you have gathered for this project, including ones imported from BibTeX, RIS, or CSL-JSON. See library & sources.
• Your project rules. AGENTS.md, voice.md, and integrity.md in the project’s .multilo/ folder — your instructions, your writing voice, and your research-integrity rules, loaded into chat and every agent.
• Agent memory. Facts you asked an agent to remember, for this project or for every project.
• The web, when you allow it. Sources Hub and the Full Draft Writer can search the web for sources your library is missing.
• Extensions and skills you install. Each one adds what it declares, and nothing more.

Because agents see the whole project, they can work across it. Ask an agent to draft your Discussion from your results, and it reads the results folder, pulls the right sources from your library, writes in your voice, and cites as it goes. A chat window only sees what you paste into it; a Multilo agent sees your project.

Where Multilo runs

Multilo is local-first. The agent loop, the tools, and your files are on your computer. The cloud is used for one job: calling an AI model.

Local and cloud

You can write, search, and read without anything leaving your device. See privacy & data.

Ways to work

Inside the app there are several ways to start a task. They all use the same agent loop, the same tools, and the same project:

• Chat — describe what you want and chat routes it to the right agent, search, or edit. Type / for slash commands.
• The Agents panel — pick an agent from the Agents Library and run it on the open document, with the MODE and model you choose.
• Inline suggestions — proposed edits that appear as you write, for you to accept or reject. See inline AI suggestions.

Chats and context

Your work lives in files, not in a chat thread. The document, the library, and the project rules stay on disk between chats, so nothing important depends on a conversation you might close.

Chats are independent

Each new chat starts with a fresh context window — it does not carry the conversation from earlier chats. What carries over is what lives in the project: your document, your library, your .multilo/ rules, and agent memory. Starting a new chat for a new task gives the model a clean slate, and a genuinely fresh second look when you want it to review something it just helped write.

The context window

The context window is everything the model can see in one request. Multilo fills it for you from:

• the instructions that define how the agent behaves;
• your voice, integrity, and AGENTS.md rules;
• your message and the conversation so far;
• the open document and your selection;
• files and sources you @-mention or attach;
• passages the agent pulls from your library, and the results of any tools it runs.

Anything outside the window is invisible to the model. That is why pointing at the exact section or source you mean gives better results than a broad ask.

When context fills up

A long agent run creates a lot of text — searches, file reads, tool results. Multilo handles this with compaction: as the run goes on, it condenses old tool results and context the model has already used, so the agent keeps its thread without overflowing the window. You don’t have to start over to keep going.

Instructions from early in a long chat can be condensed along the way. Put rules you always want followed in your project rules — AGENTS.md, voice.md, and integrity.md — rather than in a chat message. They apply to every chat and every agent run.

You can also set a per-task token budget in Settings → AI. When a run reaches it, the agent pauses and asks whether to continue instead of quietly spending more.

Stay safe with history and permissions

Two safety nets protect your work: history lets you undo changes to your files, and permissions keep you in control of what agents do.

Undo changes with history

Edits inside a project can be undone. Every write keeps the text it replaced: the last 40 versions of a document, for 14 days. Restoring an old version is itself saved as a new version, so a restore that turns out to be wrong can be undone too. Deleted files go to the project trash — the last 50 items, for 7 days.

History only covers files inside a Multilo project. A file opened from outside a project has no history, and deleting it is permanent. For a permanent record, back the project with Git and GitHub. See versions & safety.

Control what agents can do

• You see every change. Agents edit in front of you, and inline suggestions wait for you to accept or reject them.
• Agents ask before going further. Code runs in an isolated sandbox, and heavier work asks your permission first. When chat hands a job to an agent, it confirms the project before it runs.
• Spending has a ceiling. Your per-task token budget pauses a long run and asks before it uses more credits.
• Integrity rules always apply. With strict integrity mode on, the AI refuses to invent a citation and tells you when it can’t find a real source.
• Extensions show their permissions. Each extension declares what it needs and passes a trust check, and you see this before it runs.

Work effectively with Multilo

These habits get better results. For more, see Getting better results.

Set up your project once

A few minutes of setup pays off on every run afterwards:

• add your sources to the library — or let Sources Hub find them;
• teach Multilo your writing voice in voice.md;
• write your rules once in integrity.md and AGENTS.md.

It’s a conversation

You don’t need a perfect prompt. Start with what you want, then refine:

Tighten the introduction.

[The agent edits the introduction.]

Closer. Keep the thesis in the first sentence and don't add new claims.

[The agent adjusts.]

When the first attempt isn’t right, you don’t start over — you build on it. Results also vary a little from run to run, so running a step again is a fair way to get a better version.

Delegate, don’t dictate

Brief an agent the way you would brief a capable research assistant: give the goal and the context, then let it work out the details.

My results are in the results folder. Draft the Discussion section from them, cite sources from my library, and keep it under 800 words.

You don’t have to say which files to open or which tools to use. The agent works that out.

Verify before you submit

Your name is on the work, so check it. Run Claim Check as the last pass on any draft — yours or one an agent wrote — and read what you sign.

What’s next