Steering & Reasoning
How the agent decides what to do.
An agent is not a chatbot with a script. Given a request, it decides what to do — which actions to take, in what order, and when it has done enough. Steering is how you influence that decision without writing the decision yourself.
Four things shape it: what you told the agent to do, how much rope you gave it, how hard it thinks, and whether it has done this before.
The planner and the executor
Every request goes through two stages.
The planner reads your instructions and the user's input, then decides which skills to call and in what order. The executor runs that plan, calling each skill and feeding results forward.
They can run on different models, and usually should. Planning happens once per request; execution may run many tool calls. A common pattern is a heavier model for planning and a lighter one for execution — you pay for depth where the decision is made, and for speed where the work is done. Both are set on Agent Behavior.
The planner can only choose from the agent's attached Skills & Tools. A skill that isn't attached cannot be used, no matter what your instructions say.
Instructions: the one that matters most
Instructions are the agent's operating brief. The platform feeds them to the model on every turn, so the rules, tone, examples, and procedures you write there shape every response.
This is the highest-leverage page in the builder. When an agent misbehaves, the cause is usually instructions, knowledge, or skills — rarely anything else. A vague or self-contradicting brief produces an agent that fails in ways that are hard to debug, because nothing is technically broken.
The levers
These sit on Agent Behavior. Each trades something away.
Autonomy (Low / Med / High, default Med)
Independence against visibility. High lets the agent commit to multi-step plans alone; Low makes it confirm more steps. See Human-in-the-Loop.
Agent Capability (default Auto)
Depth against latency and cost. Auto lets the platform decide per request.
Response Mode (default Advanced)
Quality against speed. Advanced is slower and better; faster modes process more shallowly.
Execution / Planning Model
Cost against reasoning quality — independently, per stage.
The defaults are deliberate. Change one when you have measured a reason to, not preemptively.
Behavior settings change the agent's character, not just its performance. The same instructions run by two different models produce two different agents. Treat these as production parameters you tune and version — not defaults you set once and forget.
Planning fresh, or following a checklist
By default the planner builds a plan for every request from scratch. That is flexible and handles anything, but two runs of the same request may plan differently.
A checklist is a reusable execution plan — a known-good sequence of skill calls. The agent derives them from its own successful runs: recurring patterns become reusable plans. When a request matches one, the planner follows it instead of improvising.
The trade is flexibility against predictability.
Checklists suit repeated requests, multi-step workflows with a known order, and anything you need to review, explain, or audit.
Dynamic planning suits varied requests, new agents whose usage patterns you don't know yet, and workflows that keep changing.
Most agents start without checklists and grow into them as patterns emerge. That is the intended path, not a shortcoming.
Making reasoning visible
CoT Reasoning (beta, default off) makes the agent show its work — the reasoning steps alongside the answer. Turn it on when users or auditors need to see how a conclusion was reached, which in a regulated context is often the whole point.
This is distinct from COT Validation, where a second model reviews the output before the user sees it — that is a check, not a display. See Guardrails & Validation.
The execution trace in the builder shows the same information to you rather than to users: how the agent read your instructions, which skills it chose, how long each took. It is the first place to look when an agent does something surprising.
Where this is configured
Instructions — the operating brief
Agent Behavior — autonomy, capability, response mode, models, CoT
Execution Plan/Checklist — reusable plans
Runtime & Versioning — which executor version runs the agent
Last updated