LM-Kit OneDocs2026.11.1lm-kit.comEULA

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_reason says why a person must take over: asked_for_person, upset, legal, safety, personal_data, order_or_account or not_covered (the help center holds no answer); none when no person is needed.
  • needs_human is true exactly when there is a reason.
  • resolution_status is handed_off, needs_information (a detail is missing to answer) or answered.
  • reply is 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#

  1. Name: the name callers select the agent by. The step lists what the blueprint does.
  2. Sources (support, internal knowledge): pick the Search collections it answers from. With no collection yet, the step links to Search.
  3. Tools (automation): pick the tools it may use; each is marked as reading or proposing.
  4. 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.