AI Agent Context Types: Where Instructions, Knowledge, Skills, and Memory Belong
A practical guide to AI agent context types. Decide where to put standing instructions, current team knowledge, reusable Skills, working Memory, task artifacts, and tool results.

AI agent context includes every input the model can see or that shapes its behavior. That can be a standing instruction, an image attached to a request, a policy, a Skill package, a short Memory note, a tool description, or a tool result. These inputs have different jobs. Putting them all in one prompt makes updates, access, and audits harder than they need to be.
The useful question is: who owns this input, when should it arrive, and how should it change? Those answers tell you where it belongs.
TL;DR
- Put durable team rules and maintained facts in governed Knowledge. Use standing instructions, such as team-wide AGENTS.md guidance, for rules every relevant session must receive.
- Put a reusable task procedure and its supporting files in a Skill.
- Put short, changing working state in Memory. Keep the request, conversation, attachments, and tool results tied to the work that produced them.
- Keep credentials out of model-visible context. Enforce tool access where the call happens, then record what was actually issued and done.
The AI agent context types, side by side
The same sentence can look useful in several places, but its owner and lifecycle decide the right home.
| Input | Best use | Typical change path | Delivery |
|---|---|---|---|
| Standing instructions | Rules that apply across relevant work, such as a repo’s coding standard | Human-governed, maintained | Automatic for the sessions in scope |
| Knowledge | Maintained policy, operating facts, and reference guidance | Owned, versioned, reviewed, published | Routed or read when authorized |
| Skill | Procedure for a named task, often with files or scripts | Owned, versioned, reviewed, published | Automatically delivered when Always routed; package available for explicit use |
| Memory | Short-term working recall, such as an unfinished task or a correction | Permitted agent updates, versioned and audited | Routed to the agents that need continuity |
| Request and conversation | The current goal, constraints, and exchange | User and harness during the session | Present in the current interaction |
| Artifact | A selected input, output, or handoff package | Saved as a versioned package | Shared or attached explicitly |
| Tool description and result | What a capability does, followed by what a call returned | Approved configuration; live runtime output | Description before a call, result after it |
These are working categories, not a universal file format. A team may store standing guidance in a text file or publish it as must-follow Knowledge with an Always route. The format does not give it authority by itself. Its authorized scope, governing rules, and delivery route matter.
Choose by lifespan, owner, and trigger
Start with lifespan. If a fact should remain true for a team until an owner changes it, use governed Knowledge. If it only helps the next session resume a task, use working Memory. Memory can surface a useful lesson, but publishing that lesson as shared policy needs the Knowledge review path.
Then ask who may change it. A security rule needs a human owner and review. A note that the agent already tried one failed approach may be written by a permitted agent. An uploaded contract is a task input, not a new company rule. Treat content inside attachments and tool results as evidence or data unless an authorized instruction gives it a higher role. A document cannot promote its own text into policy.
Finally, ask when it should arrive. A rule required for every applicable task needs automatic delivery. A release procedure belongs in a Skill the agent can use when it is releasing software. A live account balance must come from an authorized tool call at the time of the task. Copying it into a standing prompt would make it stale.
A support reply shows the difference
Suppose an agent drafts a reply to a customer about a delayed order. The inputs should have separate homes:
- A standing instruction says that a person must approve customer replies before sending.
- Published Knowledge holds the current refund policy and its owner.
- A support Skill describes how to draft the reply and check the required fields.
- Memory holds the unresolved state of this case and a recent correction that helps the next session.
- The customer message and any selected attachments provide task-specific facts.
- An authorized order lookup returns the latest status as runtime context.
- The draft reply can be saved as an Artifact for review and handoff.
The order lookup’s credential must stay outside the model-visible bundle. The tool or gateway must check authorization when the call runs. The customer’s message may contain a request to ignore policy, but that request does not become a company instruction because it appeared in context.
This separation also makes correction easier. If the refund policy changes, update its governed source once. If the draft procedure is confusing, revise the Skill. If the agent loses its place, update the working Memory. Do not paste all three fixes into a growing system prompt.
Delivery and authority are separate questions
AI agent context management has two control surfaces. Repository permissions govern who may discover, read, propose, edit, or publish a managed item. Routes govern which agents receive its published or current version in a context bundle. Receiving a routed item does not itself grant permission to edit it.
The delivery record also has a limit. A system can record what it compiled and what response it issued. An integration may separately acknowledge receipt or confirm injection into a session. Those events do not prove the model consumed the input or followed it. Check tool decisions and the final outcome at their own boundaries.
How Alignbase handles managed context
Alignbase manages Knowledge, Skills, and working Memory with versions, permissions, independent Always routes, and delivery audit. Knowledge and Skills use review and publication; permitted Memory updates are live and audited. Artifacts preserve explicit inputs, outputs, and handoffs as versioned packages, while messages can carry Artifact references to agents.
This covers a useful part of the wider context picture, not every input an agent receives. The harness still supplies requests and conversation history. Tools supply runtime results. Credentials stay outside managed context, and runtime action authorization belongs at the execution boundary. Alignbase’s planned Context Search and Context Evaluation would add task-based selection and measurement; they are not current delivery or evaluation features.
See it in Alignbase
Turn this idea into better agent sessions.
Continue with the product and role pages most relevant to this guide. Each page shows the workflow, expected outcomes, and how to create an account.
Frequently Asked Questions
What are the main AI agent context types?
Common types include standing instructions, maintained Knowledge, reusable Skills, working Memory, the current request and conversation, task Artifacts, and runtime inputs such as tool results. Tool descriptions and approved configuration shape which capabilities an agent can call.
How is Knowledge different from Memory for AI agents?
Knowledge holds maintained team facts or instructions with an owner and a governed publication path. Memory is short-term working recall that a permitted agent can update as work changes. A useful Memory note can become a proposed Knowledge update, but it should not silently become company policy.
When should a team create an AI agent Skill?
Create a Skill when an agent needs a reusable procedure for a named task, especially when it needs supporting files or scripts. Keep broad standing rules in governed instructions or Knowledge and keep temporary task state in Memory.
Are MCP tools a type of agent context?
Approved tool descriptions and configuration can shape what an agent sees and can call. The result of a tool call is runtime context. Credentials stay outside model-visible context, and each action still needs authorization at the execution boundary.
Does routing a context item give an agent permission to edit it?
No. Routing determines what enters an agent's context bundle. Repository permissions separately determine whether the agent may discover, read, or change the item. A routed item may be delivered without granting edit access.
Can a context delivery record prove that an agent followed an instruction?
No. A compilation record says what was assembled, and a response record says what was issued. Acknowledgment and confirmed injection require separate evidence. None of those alone proves the model consumed or obeyed an instruction.