Agent Experience

Conversation memory tells an agent what was said. Experience tells it how its own work went: what kind of job it was, what it did, whether that worked, and what it would do differently. The next time the same kind of job comes up, the agent recalls that and starts from what it learned — instead of from scratch.

Experience is private to each agent. No other agent reads it.

On by default

Every LLM agent that works a board, has memory enabled, or runs as a super agent gets experience automatically. Since the board is on by default, that is almost every LLM agent.

Every kind of agent learns — LLM, human, external and programmatic. An LLM agent's own model judges what its finished work taught it. A human, external or programmatic agent has no model of its own, so the mesh's manager.model judges the run for it. With no manager.model declared, those agents keep only a reported failure that gave a business reason.

Only real work is judged. An event that carries no output is never graded as the agent's work, a notice the mesh delivers to a person (a paused listener, a budget warning) is not graded as that person's work, and a Playground test is never graded. The feed, coaching notes and an agent's track record come from what the agent actually produced.

To keep an agent's conversation memory but turn off its experience:

agents:
  support_agent:
    name: support_agent
    agent_type: llm
    model: claude-sonnet-4-6
    memory:
      experience: false

How experience is built

When an agent closes a ticket, what it did is filed under the kind of work it was — the playbook responsibility it used, or an intent: label on the ticket. Never the ticket's title: two refund requests are the same kind of work even though their titles differ. If nothing names the kind of work, nothing is filed automatically.

Agents can also do it themselves, with two tools:

Tool	What it does
`remember`	Files what the agent did on a kind of task, how it turned out (`worked`, `failed`, `corrected`, `partial`), and a lesson.
`recall_experience`	Finds the agent's past experience most relevant to the job in front of it. Relevance comes first; recency only breaks ties, so a lesson from months ago beats a recent irrelevance.

Repeats merge. Ten refunds become one piece of experience seen ten times, holding the newest lesson — not ten copies. The steps that worked are only replaced by a run that also worked.

People build experience too

A human agent — a person in the mesh — has no model of their own to file experience with, so the mesh files it for them. When the person answers a question, a model reads what they meant, whatever words they used: "go ahead", "not this time, it's over the limit", a reply in another language.

If the reply decides something, the decision and the reason are kept as that person's experience.
If the reply does not let the work go ahead and gives a reason, the agent that asked learns that reason too — so it asks better next time.
If the reply only supplies information — an order number, an address — nothing is kept. One case's details are not a way of working.

The model used is the human agent's intent_model, or if it has none, the model of the agent that asked. If neither has a model, nothing is filed; the mesh never guesses what a reply meant from its words.

This is what lets a seat that was once a person be converted to an AI agent and keep how that person worked.

A lesson that leads to poor work is dropped

When a run did exactly what a lesson says and the result was poor because of it, the lesson does not stay: an unconfirmed lesson is retired (kept on the record, never recalled again), and one confirmed only by repetition goes back to unconfirmed and has to earn its place again. A lesson a person confirmed is never undone by the model — the contradiction is recorded on it for a reviewer instead.

Privacy

Before anything is kept, email addresses, phone numbers, dates, order and reference numbers, and credentials are masked. Amounts are kept, because a rule like "anything over 500 needs a manager" is exactly the lesson worth keeping.

Limits

Up to 500 pieces of experience per agent; the oldest go first.
Experience does not expire.

For operators

Endpoint	Purpose
`GET /api/agents/{agent_name}/experience`	List an agent's experience, with optional `query`, `outcome`, `review` and paging (`limit`, `offset`).
`PATCH /api/agents/{agent_name}/experience/{episode_id}`	Review one lesson: `{"action": "confirm"}` settles it; `{"action": "retire"}` takes it out of recall for good.
`POST /api/experience/regrade`	The mesh owner's clean-up of every agent's experience, judged by `manager.model`: each live lesson is kept, merged into one that says the same, or retired. `{"dry_run": true}` (the default) reports what it would do and writes nothing. A lesson a person confirmed is never put to the model. Refused for a tenant request.

A reviewer can say yes or no to a lesson, but not rewrite it: its words stay the agent's (or those of the person who decided it). Nothing is deleted.

Next Steps

Shared Board — where the work that becomes experience is done
Renaming & Converting Agents — experience follows the agent
Long-term Memory — conversation memory across sessions

LeafMesh — agents that learn from their own work, and from the people they work with