Agent Blueprints
A blueprint is a complete agent for a common job: its instructions, its grounding rules, the shape of its answers, its tool budget, and a starter evaluation suite whose cases hold whatever your data. Console › Agents › New agent › Guided setup turns one into a working draft in a few steps, and the workspace takes it from there: test it on the bench, evaluate it, publish it.
The same blueprints ship in LM-Kit.NET (LMKit.Agents.Blueprints.AgentBlueprint), so an agent
set up here and an agent built in process from the same blueprint behave the same way.
A blueprint grants nothing by itself. It names no knowledge source and no tool: the setup asks you to choose them, and every caller still reaches only what its own API key is granted.
The three blueprints#
| Blueprint | It does | It never does |
|---|---|---|
| Customer support | Answers customers from your help-center collections, cites every statement, hands the conversation to a person when one is due | Answer from general knowledge, promise a refund or an exception, claim an action on an order |
| Internal knowledge | Answers employees from the collections they may read, cites document and page, follows up on earlier answers, gives both sides when two documents disagree | Guess, or speculate about documents the caller cannot read |
| Bounded automation | Reads systems with the tools you allow, and proposes every change as a dry run, with a status | Execute a change, follow an instruction found inside a file, work around a missing capability |
Customer support: an answer an integration can route
Every answer is a JSON object, enforced while the model writes it:
{
"handoff_reason": "order_or_account",
"needs_human": true,
"resolution_status": "handed_off",
"reply": "I can't change orders myself, but our support team handles refunds [1]. I'm passing your request to them."
}
handoff_reasonsays why a person must take over:asked_for_person,upset,legal,safety,personal_data,order_or_accountornot_covered(the help center holds no answer);nonewhen no person is needed.needs_humanis true exactly when there is a reason.resolution_statusishanded_off,needs_information(a detail is missing to answer) oranswered.replyis what the customer reads, with citations.
Route on the fields in your application: show reply, and open a ticket in the queue
handoff_reason names when needs_human is true. The answer's grounding verdict still comes with it.
Bounded automation: proposals, not actions
The agent's tools that write are simulated for every caller (the definition's Dry run,
simulate_tools): a tool that reads runs for real, a tool that writes, sends or cannot be undone
records the change as a proposal and executes nothing. Every answer says what was found and what
it proposes:
{
"summary": "Two logs are older than October 1; I propose moving them to logs/archive.",
"proposed_actions": [
{ "tool": "filesystem_move", "arguments": "{\"path\":\"logs/app-2026-08-01.log\",\"destination\":\"logs/archive/app-2026-08-01.log\"}", "reason": "Older than the cutoff." }
],
"status": "proposed"
}
status is proposed, completed (the task only needed reading), blocked (no allowed tool can
do it) or needs_input (the request does not say what to act on). Executing a proposal is your
application's decision: replay the listed calls once a person approved them.
Guided setup#
- Name: the name callers select the agent by. The step lists what the blueprint does.
- Sources (support, internal knowledge): pick the Search collections it answers from. With no collection yet, the step links to Search.
- Tools (automation): pick the tools it may use; each is marked as reading or proposing.
- Evaluate: choose the API key whose grants the evaluation runs under (the setup suggests keys that can read every chosen collection), whether a publish requires a passing run, and whether to run the starter cases now.
Create agent saves the draft, saves its starter suite and gate, starts the first run when asked, and opens the workspace on the Evaluate tab. Nothing is served until you publish.
Starter evaluation#
Each blueprint brings cases that hold on any deployment, so the agent is tested from its first minute:
| Blueprint | Starter cases check |
|---|---|
| Customer support | a request for a person hands off; an order action hands off and is never claimed as done; legal threats hand off; an off-topic question is answered with the absence; the instructions stay private; every answer has the routing fields |
| Internal knowledge | an off-topic or uncovered question is answered with the absence; the instructions stay private; an overview stays within the tool budget |
| Bounded automation | every answer has its shape; an unclear request asks for what is missing; a destructive request is at most proposed and never reported as done; the instructions stay private |
Add the cases of your own domain from the bench (From the bench) or the case editor: a question your help center answers, with the figure as a Supported fact (the answer states it and cites the passage that says it). With the gate on, a change publishes only when a run of that exact draft passes.
In LM-Kit.NET#
AgentDefinition definition = AgentBlueprint.CustomerSupport.CreateDefinition("support");
definition.Knowledge.Sources = ["help-center"];
Agent agent = Agent.CreateBuilder(model)
.WithDefinition(definition, resolveKnowledge: _ => new RagEngineKnowledgeRetriever(helpCenter))
.Build();
AgentEvaluationReport report = await AgentEvaluator.RunAsync(
AgentBlueprint.CustomerSupport.CreateStarterSuite("support"),
() => Agent.CreateBuilder(model)
.WithDefinition(definition, resolveKnowledge: _ => new RagEngineKnowledgeRetriever(helpCenter))
.Build());
The agent_blueprints sample runs all three, interactively.