Skip to content

Agents

Open it: Agents · first item under Agents in the console menu.

An agent is a template plus its own settings: its instructions, model, tools, memory and keys. Apps call it over HTTP; it remembers what it learns; every step it takes is checked against policy. The Quick start makes one field by field. This page covers everything you can do with it afterwards.

Items lists agents grouped by owner and project. Open one, and its page has seven tabs, in the order you usually need them.

TabWhat it is for
OverviewIts endpoints, a test box, the code to call it, its status
BuildHow it works: code, model and tools, hooks, memory, lineage
AccessWho can call it and what it may do: keys, sharing, controls, endpoints
AuditWhat it did and what changed
MetricsIts turns, failures, time and tool calls
Versions & deployIts versions and memory branches, and where it runs
SettingsName, description, environment, owner, delete

Everything an app needs, on one card: the data plane address (POST /chat), its token (make a key here), and the control plane for your backend. Below it, Test it sends messages as you, and Call it from your app has the same call in curl, TypeScript and Python. See the Quick start for each field.

Build › Code: the template it runs, as a graph and as YAML

The template it runs, with its version, as a graph of steps and as YAML. Edit in Studio opens the template; changing a template changes every agent built from it, so most agents leave this alone. See Templates.

FieldWhat it meansDefault
InstructionsWhat it is told at the start of every conversationThe template’s
ModelThe model resource it thinks withChosen when it was made
Temperature0: the same answer each time. 1: more varied0.7
Steps per messageModel and tool calls it may make before it must answer10
ToolsThe MCP tool servers it may call, and which of their toolsNone
MemoryAcross conversations: what it learns stays. One conversation: it remembers only the conversation it is in. Nothing: every message on its ownAs chosen when it was made

Save applies the change to the next message. Every save that changes something is also a new version, noted with what changed.

Build › Hooks: flows run at each phase of a turn

A hook is a flow of yours that runs at a fixed point in every turn, in the order you list them, as the caller. Use one to redact what goes in, guard what comes out, or log to your own system. The phases and the fields each hook receives are listed on the tab; writing hook flows is covered in Studio.

Build › Memory: what it remembers, by kind

What it remembers, kind by kind, with counts. You can add, change and forget entries here; a forgotten entry leaves every read at once, and the forget is kept in its history. Edit with AQL in Studio opens its memory as AQL. To browse across agents, use Memory.

KindWhat it holds
WorkingWhat it holds for the task at hand
EpisodicWhat happened: its turns, one by one
SemanticFacts it knows
ProceduralHow it does things
ToolsThe tools it knows about

Shared knowledge can be attached: a semantic space it recalls from on every turn, without owning it.

Build › Lineage: inherit, fork, branch, merge, evolve, with its ancestors and descendants

Where it came from and what was made from it, and the ways to make more:

ActionWhat you getIts memory
InheritA new agent, a child of this oneStarts its own
ForkA new, independent copyA copy of this one’s, then its own
BranchThe same agent, with a branch to try changes onA branch of its memory; the agent itself is untouched until you merge
MergeA branch brought back into the agent, if nothing conflictsFacts and procedures learned on the branch are added
EvolveA branch that can’t merge becomes a new agentThe branch’s memory

Branches are tried and merged on Versions & deploy.

Access › Keys: the keys apps call it with

An app needs a key to call the agent. A key (a3tk_…) reaches this agent only, through POST /chat with a session_id that starts with this agent’s id. It acts with the roles of the person who made it, never more. Each key shows when it was last used. Revoke stops it on the next call. Deleting the agent revokes all its keys.

Access › Sharing: this project, chosen namespaces, or public

ChoiceWho can use it
This project (default)Only its own project
Chosen namespacesThe projects you add, each with its own rights: Call, Inherit, Fork, Merge back
PublicListed for every organisation on A3T

Sharing never hands over its memory.

Access › Controls: block calls, pause its deployment, revoke its tools

Ways to stop it, each at once and each reversible:

ControlWhat it does
Block callsEvery call to it (POST /chat, its webhook) is refused. Its record and memory stay
Pause its deploymentA deployed agent stops taking work; callers get the paused response. An agent on the shared runtime can’t be paused alone: block it instead
Revoke its toolsTakes away its tools without changing anything else

The tab also says what runs around every turn: its hooks, and the core agent’s error handler, which answers every failed turn.

Its addresses: the data plane (POST /chat, session <agent id>:<session>), its webhook (POST /webhook/agent/<agent id>/chat) and the control plane, each with whether it is open or blocked.

Audit: policies that decided about it, a policy test, and its history

  • Policies that decided about it and Test a policy: what a policy would decide if a given role called it to use a tool, its model or a flow. Decisions themselves are shown to SuperAdmin and SecurityAdmin.
  • Audit log: its calls, test chats and, for InfoSec, each allowed or blocked decision.
  • Changes: who changed what and when: settings saved, memory edited or forgotten, shared, blocked.

Metrics: turns, failures, time, tool calls

Turns, conversations, failures, average and p95 turn time, tool calls and steps per turn, for the last 24 hours, 7 days, 30 days or all time.

Versions & deploy: deployment, versions, branches and forks

SectionWhat it does
DeploymentWhere it runs. Pick a canvas preset (how it should run) and Deploy to give it its own runtime; until then it runs on the shared runtime. See Canvas
VersionsEvery version: code (template version), a tag on its memory, a note, who and when. A save that changes something makes one; Make a version makes one by hand
BranchesMemory branches. Try it on this branch chats with the agent on the branch; Merge or promote… shows what the branch changes, then merges it or promotes it to a new agent
ForksAgents forked from it

Settings: about it, where it comes from, delete

FieldWhat it means
NameIts name, agent_<project>_<name>
EnvironmentWhere its owner puts it: dev, test or prod
DescriptionWhat it is for, shown on its Overview and to reviewers
Where it comes fromIts template and version, how it was made, its id, project, owner and creation time
Delete this agentRemoves the agent, its values, its endpoint (apps calling it get an error) and its own canvas, and revokes its keys. Its template is untouched. Type its name to confirm

To move an agent to another project, clone it there and delete this one.