Build your SecOps, trading, bidding, monitoring or integration agent. Your CISO, chief compliance officer, CMO, COO or CTO will say yes. Build your
SecOps agent.
Your CISO
will say yes.

AgentLM is A3T’s agent model. It runs on a single GPU inside your tenant, reads agent memory directly, and works inside your workflows and policies. Every request starts at a gate where AgentLM decides whether it can solve the request, how much thinking it needs, or whether to escalate to a frontier LLM. Its answer is a workflow that has been checked before it runs.

How it works

1. Solve-or-escalate gate. The model’s first layers estimate whether it can solve the request, which skills it needs and how much to think. If agent memory has no matching procedure, evidence or concept, it escalates regardless. A request it keeps costs nothing extra; one it escalates costs a fraction of one pass.
2. Reads memory directly. Knowledge-graph nodes are precomputed into attention blocks stored in agent memory. AgentLM attends to them instead of pasting text into a prompt.
3. Fixed-size sessions. A session is a fixed-size state plus a short window of recent text, saved to memory after every turn and restored on the next. Each turn processes only its new tokens.
4. Answers are workflows. Output is constrained to the CNCF Serverless Workflow schema and dry-run in A3T before it is returned.
5. Learns from outcomes. Verified outcomes and workflow changes are written back to memory. A background job consolidates episodes into knowledge for the next request.
6. Skills without retraining. Domain and tenant skills are small adapters stored in memory and paged onto the GPU when the gate asks for them. A new domain means training one adapter, not a new model.

Early access covers the core model, memory attention and the solve-or-escalate gate. Skill adapters and trained thinking budgets are on the roadmap.

Workflows are written in the open CNCF Serverless Workflow spec and run on a Rust runtime with microsecond dispatch. Inputs are typed, every step is checkpointed, and the execution path is monitored. Only deviations from it go to a model: AgentLM first, a frontier LLM only if AgentLM escalates.

How it works

1. Typed inputs. Every workflow declares its input schema, so bad input is caught at the edge instead of halfway through a run.
2. 26 task types. Agent, model, MCP tool, human approval, switch, loop, transform, emit and more. Routine steps never spend a token.
3. Triggers and sandboxes. Start flows from webhooks, schedules and events, and run tasks in isolated or shared sandboxes.
4. Checkpoint and resume. State is saved after every task. A failed or restarted run resumes at the failed step without repeating side effects.
5. Monitored execution. Each run is compared with the expected path and recorded as an execution graph in agent memory. That graph is what AgentLM reads to handle a deviation and propose a change.
6. Versioned changes. A proposed change becomes a new workflow version once it is approved. The same YAML is on the canvas and in Git.

document:
  dsl: '1.0.0'
  namespace: secops
  name: contain-host
input:
  schema: alert.v2
do:
  - triage:
      call: a3t:agent
      with:
        message: ${ .alert }

Agent memory is one store for everything an agent knows: five memory types, a knowledge graph, and the sessions and attention blocks AgentLM reads directly. It is queried with AQL, the Agent Query Language, and every recall and write is checked against policy.

How it works

1. Five memory types. Working, episodic, semantic, procedural and tool memory. Proven procedures are reused, so agents stop asking a model for what they already know.
2. AQL. RECALL, STORE, LINK and FORGET. Queries read like what the agent wants to know.
3. Knowledge graph. LINK connects memories into a graph agents can traverse, not just a pile of vectors.
4. Model memory. AgentLM’s sessions and attention blocks live here too. On a model upgrade they are recomputed from the source data.
5. Scopes and sharing. Namespaces keep agents and tenants apart; shared scopes let a team’s agents learn from each other.
6. Retention and a real forget. TTLs, history when facts change, and FORGET that actually removes data.

RECALL FROM EPISODIC
  WHERE host = "lt-4471"
  FOLLOW LINKS TYPE "resolved_by"
    INTO PROCEDURAL
  RETURN pattern, confidence

The A3T policy gateway sits between any agent and the tools it uses. It plugs into your identity provider (Keycloak, Entra, Okta, Auth0, Google or any OIDC), verifies the agent’s own identity and the user’s delegation on every call, decides with Cedar, and attaches the downstream credential itself. Agents need no auth code.

How it works

1. An identity for every agent. Each agent gets a stable ID with a human owner and a class that policy can target, plus a short-lived workload token at start. It can be mirrored to your IdP, such as Entra Agent ID.
2. Delegated, not borrowed. The user signs in through your IdP and delegates a scope, a set of tools and an expiry. Token exchange carries the user as subject and the agent as actor (RFC 8693, Entra on-behalf-of, ID-JAG).
3. One gate for every tool call. Agents call tools through A3T’s MCP gateway. It verifies both identities, loads the user’s live roles, decides with Cedar, then acts. Agents only see the tools they may use, and risky calls can wait for a human approval.
4. Agents never hold credentials. The gateway keeps the downstream tokens and uses the user’s own delegated token wherever the app supports it, so the app’s permissions still apply. Nothing is written into the agent, its logs or traces.
5. Access changes reach running agents. A role change pauses affected runs at the next checkpoint. A leaver’s runs are stopped, their delegations revoked and their tokens deleted.
6. Audit you can prove. Every decision is logged with agent, user, delegation, tool and the policies that decided it, and exported over OpenTelemetry to your SIEM. Policy diffs and shadow mode show what a change would allow or deny before it ships.

permit (
  principal in AgentClass::"itsm-assistant",
  action == Action::"servicenow__create_change",
  resource
) when {
  context.on_behalf_of in Role::"change-requester" &&
  context.now < context.delegation.expires_at
};