Understand agent templates Private Preview
Learn how agent templates connect Atlan to your knowledge sources over MCP and turn what's written there into governed context, one outcome per template.
Agent templates connect Atlan to the systems where your knowledge already lives, over MCP, and turn what's written there into governed context in your context layer.
Each template is built for one outcome. You pick the template for the outcome you want, connect the sources it needs to read, describe what you are after, and the agent does that job repeatedly and consistently, citing its source every time.
The outcome available today is business graph term creation and enrichment. That's the first outcome, not the boundary of the capability: the same pattern applies to any outcome that enriches the context layer, and further templates are being built. What changes between templates is the outcome and the skills packaged to achieve it. What stays the same is the shape: connect a source, scope it, say what you want, preview, then run.
Agent templates are distinct from collection enrichment. Context agents enrich assets you already have in Atlan, working from query history and lineage inside the platform. Agent templates reach outside Atlan, read the documentation your teams write, and create context from it.
Why templates rather than prompts
A single generic agent produces generic output. Building a bespoke agent for every team requires skills most teams don't have and nobody wants to maintain.
A template sits between the two, and it's more than a prompt with a form around it. Atlan packages the prompt together with the skills that make a run reliable, the quality gates a run must pass, and the write path into Atlan.
Skills are what make runs reliable
A skill is a reusable, named capability that tells an agent how to perform a task: the business logic to follow, the steps to take, and the edge cases to call out. Skills are first-class assets in Atlan, so they're versioned and one skill can serve many agents.
Every template ships with a set of platform skills, bound in a deliberate reading order, covering the parts of the job that are easiest to get wrong:
- Reading a source well. How to search a repository or a space, and how to tell a page worth extracting from one that is not.
- Checking what already exists. Before creating anything, the agent queries Atlan itself through Atlan's MCP server to find what your glossary already holds. A candidate that matches an existing term enriches it rather than creating a duplicate, and a definition a person wrote is left alone.
- Extracting with evidence. Producing a definition together with the citation that supports it, rather than a plausible sentence with no source.
- Passing the quality gates. A run is graded before it publishes. Every term needs a citation, duplicates within a run are rejected, and content a person authored isn't replaced.
- Writing into Atlan correctly. Creating the glossary, categories, terms, and READMEs in the right order, with the right attributes.
Platform skills are always bound and can't be removed. That's what keeps output consistent across every agent built from the same template, and it's the difference between an agent that works on your first attempt and a prompt you have to tune for a week.
You can add your own skills on top, for house rules a template can't know. See Create an agent from a template.
What you supply
Four things, and none of them is the prompt:
- The source to read
- The scope to focus on inside it
- The run instructions saying which terms you want extracted
- Optionally, your own skills for conventions specific to your organization
What you can create today
| Template | What it does | Availability |
|---|---|---|
| Business Graph Term Generator | Creates or enriches business graph terms and categories from your docs, and links them to the assets they describe | Available |
| Knowledge Curator | Curates a golden layer of SOPs and policies into governed Knowledge Files | Coming soon |
| Code & API-Spec Lineage Agent | Reads OpenAPI specs and ETL code in Git, then stitches column-level lineage from tables through to API paths | Coming soon |
| Skill / AOP Compiler | Converts recurring procedure logic in your playbooks into reusable, persona-scoped Skills | Coming soon |
Templates marked coming soon appear in the picker but can't be used yet. Selecting the bell on a template card records your interest, and that signal decides which pipeline is built next.
If the outcome you want isn't in the catalogue at all, use Looking for another agent? Tell us what you need at the foot of the picker and describe it in your own words. That reaches the Atlan team directly.
What Business Graph Term Generator does
The agent works additively. Across a run it:
- Create a term for each business concept it finds
- Enrich an existing term that has no definition
- Attach a citation to every term, so you can trace where a definition came from
- Leave definitions a person wrote in place, enriching only what's empty
Agents are instructed and gated not to replace a definition, term link, or README authored by a person. They fill what's empty and refresh only content they generated themselves. Every value an agent writes is tagged isAIGenerated, so you can audit exactly what an agent has touched.
What runs write, and where
Every run publishes into a single business glossary named after your agent. Re-runs accrue into that same glossary rather than creating a new one, which is what makes a scheduled agent useful over time.
A run creates:
- One glossary, named after the agent
- Categories, to group the terms it finds
- Terms, anchored to the glossary and assigned to a category
- READMEs on the glossary and its categories
Terms are published live and tagged isAIGenerated, so you can find and review everything an agent has written anywhere in Atlan. Review happens in Atlan's normal glossary flow.
Because your agent's name becomes the glossary name, and the name can't be changed after creation, choose it deliberately. See Create an agent from a template.
How agent reads your sources
An agent reads through a knowledge source that an admin connects once, in Settings. The connection holds a read-only credential you provide, and that credential is the access boundary: the agent can read exactly what the token can read, and nothing more.
No end user is asked to sign in to a source, and the connection can't write back to it.
See Knowledge sources for the sources you can connect and how to set each one up.
Sample runs and full runs
Every agent supports two kinds of run.
A sample run reads a small part of your sources and proposes a handful of terms so you can judge quality in a minute or two. It publishes nothing to Atlan.
A full run does the work properly and publishes to your glossary.
The intended loop is to sample, read what comes back, adjust your instructions, sample again, and only then run in full. A sample run is a quality signal about your instructions, not a shortlist of terms to approve. A full run re-derives everything from scratch.
Need help
If you need assistance after reviewing this page, contact Atlan support.
See also
- Create an agent from a template: the six-step setup flow
- Write run instructions: the field that decides what you get back
- Run and schedule an agent: runs, settings, versions, and cadence
- FAQ - Agent templates: common questions, and what's in the works
- Knowledge sources: connect GitHub and Confluence