What an agent can do

Every connected agent holds the same Mana tools, whichever client it is: the same set reaches Claude Code, Codex, OpenCode, claude.ai and ChatGPT. Your role sets the actions of your grant, and the actions decide which tools your agent sees. A member's grant carries the add action. An admin's grant also carries the correct and admin actions.

A member's agent holds 20 tools. An admin's agent holds 22, because it also holds mana_memory_dismiss and mana_skill_write. A tool that your grant does not carry is not in the list, and a call by its name fails.

A call counts against your plan's monthly model calls only when it reads and runs a model: mana_answer, and mana_search or mana_retrieve when the store ranks the matches with a model. Reading, listing, and storing count nothing. At the limit of your plan, a call that would run a model is refused. Every other call keeps working, within the rate limit.

With any grant

Tool	What it does
`mana_standing_instructions`	Returns the rules, the glossary, the configuration records and the usage meter.
`mana_search`	Finds records by words. Returns titles, excerpts, kinds and dates.
`mana_retrieve`	Builds one evidence pack for a question, with the id of its trace. `mana_evidence_feedback` needs that id.
`mana_answer`	Writes one cited answer from the evidence.
`mana_memory_list`	Lists memories by key, by key family or by type, with a preview of each.
`mana_memory_read`	Returns one memory in full, with its evidence and its revisions.
`mana_skill_read`	Returns one skill by its key, or one part of it by its path. For a hosted skill, it returns the address. Mana never runs a part under `scripts/`.
`mana_provenance`	Says where a record came from and what it was derived from.
`mana_explain_access`	Says why you can read a record, or why you cannot.
`mana_context_list`	Lists what a context directory holds.
`mana_context_read`	Reads one context entry.
`mana_session_read`	Reads a stored agent session.
`mana_evidence_feedback`	Records whether the evidence of a retrieval was useful.

Six tools declare the fields of their result before the first call, for a client such as ChatGPT: mana_search, mana_answer, mana_memory_list, mana_memory_read, mana_standing_instructions and mana_provenance.

With the add action

Tool	What it does
`mana_remember_interaction`	Stores a statement and its memory in one transaction. An agent uses it for a decision, a learning, an idea or a setting.
`mana_remember_batch`	Stores up to 100 of those in one call.
`mana_remember`	Stores a memory bound to evidence that is already in the store.
`mana_memory_propose`	Proposes a memory that the agent inferred from a session. It stays out of search, and no agent can accept it.
`mana_session_start`	Opens a session to record what an agent did.
`mana_session_append`	Adds a message or a tool result to that session.
`mana_session_commit`	Closes the session.

The four tools that write a memory name it with a memoryKey, such as learning/<slug>, idea/<slug>, config/<area>/<name>, or note/<slug> for a statement with no family. The store refuses a write with no key before it stores anything.

Search finds a new memory by its words at once. It also finds it by meaning at once, within a bound of your plan:

Free: up to 1 new memory a second.
Pro: up to 100 new memories a second, which Pro calls realtime indexation.

Search finds a memory past that bound, and every vault note, by meaning within five minutes. This counts no model call.

With the correct action

Tool	What it does
`mana_memory_dismiss`	Retires a memory that you can read, yours or another person's. The store keeps it as a rejected revision.

A write under a key that already exists is a correction, and it needs the correct action too. Give a changeReason. Mana records a new revision and keeps the prior one, so the history is linear and nothing is overwritten. A correction that repeats the stored text word for word stores nothing, and the result says so.

With the admin action

Tool	What it does
`mana_skill_write`	Adds a skill to the organization, or revises one with a reason. Mana records a hosted skill by its address, and stores any other skill in full. Every agent of the organization then sees it.

What no agent can do

No tool deletes anything, in any grant. A person deletes a memory, in the dashboard: Your data gives the steps. mana_memory_dismiss retires a memory and keeps it.

Store many at once

Some clients ask a person to approve each call. One mana_remember_batch call replaces up to 100 approvals.

The store writes each entry on its own. If it refuses one, the others still go in, and the result names it by its position.
An entry that is already stored under its key, with the same text, writes nothing. With the correct action, the result reports it as existing. Without it, as with a member's grant, the result reports it as refused.
To resume a load that stopped, send again only the entries that the result did not report as stored.
Two entries of one call cannot share an interaction id or a memory key. The store refuses such a call before it writes anything.

What a judgment adds

When the judgment model of your organization's deployment is on, two results carry one more field. Neither field changes what you can read.

Where	Field	What it says
`mana_answer`	`evidenceOmitted`	On an investigation or a period summary larger than the token budget of the answer: how many authorized blocks the answer did not read. Each record gives one block before any record gives a second. Ask a narrower question to read the rest.
`mana_answer`	`verification`	For each citation, the probability that its block supports the claim, and a verdict: supported, unsupported or uncertain. A second check reads the whole answer. The answer reads `verified` only when both checks find support, `unsupported` when either check fails, `partial` when a part was not checked or a verdict is uncertain, and `unavailable` when the check did not run. With a `confidential` block in the evidence, nothing goes to the check: the field reads `partial` with no verdict, and `withheld` counts the unchecked citations. An answer with no field was never checked.
`mana_search`	`judgment`	`judged`: a model scored the top results for relevance to your question and reordered them, each with its `relevance`. `unavailable`, with a reason: you got the deterministic order. The judgment never adds or removes a result.