What Neo remembers
Facts
Durable truths about a client — the apps they run, who their VIPs are, their environment’s quirks.
Rules
Handling that kicks in for a specific situation — who to escalate to, where to route certain tickets, a client’s exception to your usual process.
Preferences
Tone, terminology, and key contacts — how to communicate and who to notify for each client.
Memory vs. custom instructions
Every agent run gets a memory index: one line per unpinned memory for your MSP and the ticket’s or chat’s company, the memory’s description. When a line matches the work, the agent loads that memory’s full text before it acts. So Acme’s “New starter onboarding — accounts, licences, laptop” is loaded on an Acme new-starter ticket and ignored on a printer ticket, and a long procedure costs nothing on the runs it does not fit. The description decides whether a memory is used. A vague one (“Notes”, “Important”) never matches the work. A rule every run must apply without looking for it — a sign-off, “always set the Site Code custom field” — is pinned instead, so it is in every run in full. Standing, org-wide procedures that apply across every client — your documentation process, your change-approval policy — belong in the agent’s custom instructions, or in a skill when only some runs need them. A procedure for one client, such as that client’s new-starter steps, is a memory scoped to that company.Pinned vs. unpinned
- Pinned memories are always included — Neo never misses them. Pin what’s relevant on every run for a client, e.g. “Acme’s VIPs are CEO Jane Doe and CFO Mark Lee — treat their tickets as top priority.”
- Unpinned memories are the default — every run sees their one-line description in its memory index and loads the full text when it fits the task, e.g. “Escalation contact: Peter Nguyen, Service Desk Manager” is loaded when a ticket needs escalation. Most memories should stay unpinned.
Neo suggests the pin
The memory window has a Pin switch. While you write a new memory, Neo reads the text and turns Pin on for a rule every run must follow, such as a sign-off, a language, a never rule or a VIP list, and says why under the switch. When you use the switch yourself, Neo leaves it as you set it. If your classic workflows are on, Neo also turns it on for a rule that changes their decisions, because they read pinned memories only. When you edit a memory, Neo never moves its pin. It suggests pinning a rule every run must follow. It suggests unpinning a memory that agents can find by its description only when you have no classic workflow switched on, because a classic workflow can read a memory only while it is pinned. To pin or unpin, use the switch and save: the text and the pin change in one save, so you can unpin a memory and make it longer, or shorten one to 500 characters and pin it. A pinned memory that names one action applies to that action only. “When dispatching any ticket, look at the service board team” guides dispatch; it does not change another step in an agent’s instructions, such as “Assign to Neo Administration”. Length: an unpinned memory holds up to 10,000 characters of markdown — headings, lists and tables are fine — and the editor warns above 6,000, because an agent loads the whole text. Write one memory per subject. A pinned memory holds up to 500 characters; a pin stored before this limit keeps its length, but an edit cannot make it longer. You can edit any memory’s text in the dashboard. Save changes the memory in place, so links to it still work; editing a pinned memory keeps it pinned.What to pin
- Pin only what every run needs. Pinned memories go into every prompt, in full. Pin a client’s tone, sign-off, formatting, a few VIP names, or a short “never” rule. A rule for some tickets, such as one company’s incidents or one approval exception, stays unpinned with a description that names the case. Pin it only when it changes what a classic workflow’s action decides (Ticket Triage’s fields, Ticket Dispatch’s technician, Acknowledge Issue’s reply, L1 Engineer’s steps) and that workflow works those tickets, because classic workflows read pinned memories only. Your Neo Support Agent checks your workflows before it pins a rule like this.
- Everything else stays unpinned. Agents load an unpinned memory when its description matches the work: procedures, environment notes, contacts, client history.
- One note, one memory. Never split a note into several pins. For several companies, select them all when you create the memory; Neo saves one memory for all of them, and an edit changes it for every company.
- Keys and passwords. A key or password an agent needs for its work, such as the install key a deployment agent uses, can be in a memory. Give it a memory of its own and leave it unpinned, so only the runs that need it load it. When you leave Used by to Neo, Neo hides a memory that holds a key from end-user chat and phone, when you create it and when an edit changes its text. When you chose Used by in an earlier save, an edit of the text keeps your choice, and Neo warns you if end-user chat and phone can read the key. A save in which you pick Used by keeps your pick, with no check and no warning. Keep a secret no agent needs in your password manager or documentation platform.
Keep memories current
- Look before you add. Search the list for a memory on the same subject first. When one exists, edit it and add the new detail there. Two memories on one subject drift apart, and each one takes an index line and a place in the budget.
- Say when a fact ends. A fact that is true for a period, such as a technician’s leave or an office move, states the date it ends: “Kim Rivera is on leave until 2026-11-04”. Never save a fact whose date has passed. Agents read a memory until you delete it, so delete it after its date.
- Fix what you find. A procedure split into parts, two memories on one subject, or a date in the past: merge the parts into one memory and delete the rest. Your Neo Support Agent lists a company’s memories before it saves a new one, and offers these fixes when it finds them.
Budgets per run
One agent run reads at most 100 unpinned memories and 4,000 characters of pinned memories. Each budget counts the MSP-wide memories plus one company’s, so you split it between them as you like. A memory limited to some agents counts only for those agents. The Pinned budget and Unpinned budget cards on the Memory page show how full each budget is. Each card shows the fullest run: the MSP-wide part, the company that holds the most and, when restricted memories make one agent’s run fuller, that agent. The bar turns amber at 80% and red when the budget is full. A save that would pass a budget is refused, and the message names the company and the agent. For an MSP-wide memory, Neo checks it against the company that holds the most. To make room, delete or merge memories, unpin a memory no run needs in full, or limit a memory to the agents that need it. Select Optimise with Neo on the Memory page to do this clean-up with your Neo Support Agent. It opens a chat with a ready request: Neo Support reads the budgets, reviews your memories, and proposes merges, deletions and pins to remove. It makes each change only after you agree. The button turns blue when a budget passes 80%. You can also ask it to tidy one company’s memories.Description
Every memory has a description: one line, up to 120 characters, that names the subject and when it applies, such as “New user onboarding — accounts, licences, laptop”. For a short fact, the description can be the fact itself. Neo writes it from the content, so the field is locked until you click Edit to write your own. When you change a memory’s content, Neo writes a new description to match, unless you edited it yourself. Agents see only this line until they load the memory, so name the work it applies to. Leave out “MSP-wide” and the memory’s companies: the page shows them, and an agent sees a memory only on the runs it applies to. Neo removes them from the start of a description when you save.Scope
Choose who a memory applies to:- Company-specific — applies only when Neo works for one of the end-client companies it lists. One memory can list several companies.
- MSP-wide — applies across every client, e.g. your internal standards or tooling.
Used by
Used by sets which agents use a memory. The memory’s window and its row on the Memory page use the same words. Pick one of four options:
End-user chat and phone
Your end-user Chat Agents in Teams and Slack and your Phone Agents talk with your clients’ staff live, on faster, smaller models. Keep from them what must never be said to a client’s staff. Triggered and scheduled agents also write to your clients’ contacts, through the PSA, but they run on stronger models that are much less likely to repeat what they should not. Leave everything else on All agents, so your end-user Chat Agents know each client’s processes, contacts and preferences. To control what an agent may tell a user, write it in the memory (“never reveal these tags”). When you save a new memory with such content, Neo picks All agents except end-user chat and phone and says why in the window, for example Neo chose this: it names or describes your clients. The row on the Memory page then carries a Neo tag. You can change it at any time. Neo checks the text again each time you change it and leave Used by as it is. When Neo chose the memory’s Used by, Neo picks again: it hides the memory when the new text holds such content, and makes it available again when the text no longer does. When you chose Used by in an earlier save, Neo keeps your choice. If end-user chat and phone can still read the memory and the new text holds such content, Neo tells you why and offers Hide from end-user chat and phone. A save in which you pick Used by, or that changes only the companies or the description, gets no check.Specific agents
By default every agent that works for a company reads that company’s memories. That is usually what you want. An MSP chat agent, your Neo Support Agent included, has no company in context: it reads the MSP-wide memories, and a client’s memories when you name the client or one of its tickets. When a fact belongs to one job and nowhere else, pick Specific agents. Reach for it when a memory helps one agent and is unhelpful — or unsafe — everywhere else:- A deployment value your EDR agent needs, which has no business in an agent that writes to customers.
- A billing rule only your invoicing agent should apply.
- A long runbook that would crowd every other agent’s context for no gain.
- A list one phone number routes callers on. Each Phone Agent number is in the list as Phone · number · name.
If you delete an agent a memory was limited to, the memory is left with no reader. The Memory list counts that agent as a hidden agent, and shows No agent in amber when no agent you can see reads it, so check it after you remove or replace an agent.
restricted_to_agent_ids when you create or supersede a memory; a phone agent is phone:<id>, with the id from GET /public-api/phone/numbers.
Memories Neo learns from its runs
Neo reviews its own agent runs. When a review finds a durable fact that would help later runs, such as the ID of a status in your PSA, Neo saves it as a memory straight away. It does not ask you first. It then tells you in your Inbox, with the text it saved. A memory Neo saves this way:- Shows Reviewer as its source on the Memory page. Filter by that source to see them all.
- Applies MSP-wide, or to one company when the fact is about that company.
- Never overrides your agent’s custom instructions. When it says a step cannot be done and the instructions ask for that step, the agent still does the step, and reports it if the step fails.
- Is unpinned. When the fact is about one agent’s own setup, such as the Teams channel it posts to, a field Neo sets when that agent writes, or the ID of a status that agent’s instructions name, only that agent uses it, and Agents names that agent. Every other fact has no Agents limit. Neo writes its description. When the memory holds a secret, names your clients, or holds your prices or an opinion about a person, Neo keeps it from your end-user chat agents and the Inbox note says why.
Add a memory
Only admins can add, edit, pin, or delete memories — including through a chat agent (an agent saves a memory only when the person chatting is an admin). Everyone’s agents still read them.
1
Open Memory
Go to the Memory section in the dashboard.
2
Write the memory
Select New memory and enter the fact, rule, or preference in plain English. Add a one-line description, or leave it to Neo.
3
Set the companies and Used by
Pick one or more companies (or All companies for MSP-wide). Neo saves one memory for all of them, and you can add or remove companies when you edit it. If a memory already holds the same text, Neo saves no second copy: it shows you that memory, so you can edit it or add your companies to it. Then check Used by: Neo suggests All agents or All agents except end-user chat and phone, and you can change it. Pick Specific agents only when the memory belongs to one job.
4
Check Pin
Neo turns Pin on for a rule every run must follow (how Neo decides). Turn it on or off yourself, then select Create memory. If the pin budget is full, Neo saves the memory unpinned and tells you which company and agent have no room.
Find a memory
Each row on the Memory page shows its companies (two names, then +N; the memory’s window lists them all), its description, and its Used by setting in the words of the window. A Neo tag marks a memory Neo kept from end-user chat and phone; hover over it for the reason. A memory limited to specific agents shows two names, then +N. Select a row to open the memory; close it, or go back in your browser, and the row flashes so you see where you were. Filter the list by company, Used by, pin and source, or search the text. The Used by filter shows the memories hidden from end-user chat and phone, the ones Neo hid, or the memories one agent reads: the ones for its kind of work, so an end-user Chat Agent gets no memory hidden from end-user chat and phone, and only the specific-agent memories that name it. Classic workflows are not in that filter.Earlier versions
When you edit a memory’s text, Neo keeps the text it replaced as an earlier version, with the time of the edit. The memory keeps its place, its pin and its links. The Memory page shows only the current text. To learn which text a past run followed, ask your Neo Support Agent, for example “which version of our dispatch memory did yesterday’s run read?”. It reads the earlier versions and quotes the one the run read. Through the public API,GET /public-api/memories/<id>/versions lists them.