SMELT

Agent Blocks

Every AI step in a SMELT workflow is a block from the AI section of the palette. Each takes input from upstream blocks, calls a model, and produces output the rest of the workflow can reference. Eight AI blocks ship:

  • Auto Agent - decomposes a goal into sub-tasks at runtime.
  • Agent - runs one of your saved agents.
  • Research - gathers and synthesises information.
  • Reasoning - chain-of-thought analysis.
  • LLM - a direct model call with your own prompt.
  • Knowledge - retrieves context to ground a downstream block. See Knowledge Base.
  • Custom A2A - delegates to an agent outside SMELT. See Custom A2A. Pro and Business.
  • Content Safety - screens text and branches on the verdict. See Content Safety. Pro and Business.

The five general-purpose blocks are covered below.

Research Agent

Searches the knowledge collections you choose and writes structured findings from what it retrieves, citing the documents it used.

Use it when your workflow needs to gather facts before reasoning.

  • Model - any supported LLM. Defaults to the plan tier preset.
  • Prompt - the question to answer from your documents.
  • Collections - which knowledge collections to search. Without at least one, the block has nothing to search.

It cites only documents it actually retrieved. When no collection is selected, or nothing matches, it returns no findings and says so rather than answering from the model's own memory.

To search the web, or to hand raw context to another block, use the Knowledge block.

Reasoning Agent

Performs chain-of-thought analysis on input data.

Use it for classification, analysis, summarisation, or any task where thinking quality matters more than tool access.

  • Model - higher-capability models (Sonnet, Opus) produce better reasoning chains.
  • Prompt - define the reasoning task and expected output format.

Self-consistency voting is not a setting on the block. It comes from the Effort level on a saved reasoning agent: higher effort adds self-consistency voting and critique passes. Save an agent with the effort you want, then run it from an Agent block.

LLM

A direct call to a language model with your own prompt and no structural constraints. Use it when none of the specialised agent shapes fit and you need raw model output - drafting copy, transforming text, classifying input, ad-hoc completions.

Tool calls go through Action workflows (configured via integrations) rather than the LLM block, which keeps prompts simple and outputs inspectable.

  • Model - any supported provider. Sets the cost ceiling for the call.
  • Prompt - the full instruction set. Variables from upstream blocks are interpolated.

The block returns whatever the model wrote. There is no output-format setting: if you need JSON downstream, ask for it in the prompt, then parse it with a Code block.

Auto Agent

A planner-as-orchestrator that decomposes a goal into a sub-task DAG at runtime. The Auto Agent decides which agent types to invoke, in what order, and with what inputs.

Use it for open-ended tasks where the optimal plan depends on the input. The Auto Agent handles routing, fan-out, and aggregation internally.

  • Model - use a high-capability model. Planning quality directly affects execution quality.
  • Prompt - describe the goal. The Auto Agent generates the plan.
  • Available agents - which agent types the planner can dispatch to. The Studio palette restricts this to Research and Reasoning.

Agent

Runs one of your saved agents as a step in the workflow. Where the Research, Reasoning and LLM blocks carry their prompt on the canvas, a saved agent carries its own instructions, effort level, Content Safety tool, sub-agents and memory, and you reuse it across as many workflows as you like.

Only published agents appear in the picker. If you have none, the block tells you so and links you to the agent editor.

  • Agent - which of your published agents to run.
  • Version - the exact published version to run. The block pins it, so publishing a new version never changes a running workflow behind your back. When a newer version exists the block shows a "v3 available" hint; pick it from the list when you are ready.
  • Input - what the agent should work on. References like {{block.field}} resolve from upstream blocks.

Research agents and their collections

A saved agent on the Research baseline answers only from the knowledge collections you tick in the agent editor. Pick them once, where the agent lives, and every workflow that runs it searches the same documents.

The same selection travels when the agent is delegated to. Attach a research agent as a sub-agent of a core or reasoning agent and the delegated task searches the collections that research agent was published with.

With no collection ticked the agent has nothing to search: it returns no findings and says so, rather than answering from the model’s own memory. A collection you later delete is dropped from the search and the rest still run.

Tools

Core and reasoning agents can attach the AI-powered Content Safety tool to screen text mid-run. The agent calls it, gets a verdict on whether the text is harmful, and can branch or stop based on the result.

The verdict includes:

  • flagged - true when the text reaches the severity threshold you set.
  • max_severity - the highest severity (0 to 7) across all four categories.
  • categories - the raw severity of each category (Hate, Violence, Sexual, Self-harm), so you can branch on individual categories.

Two modes:

  • Fixed - you set the severity threshold and categories when attaching the tool. The agent uses your settings for every call.
  • Let the agent choose - the agent picks the threshold and categories per call.

The tool is metered per record and available on Pro and Business plans. See Content Safety for details on screening text with a dedicated block.

The agent decides which text to pass to the tool, so give it clear instructions and use a capable model. When you need to screen a specific piece of text with no model in the loop, use the Content Safety block instead.

Sub-agent delegation

A core or reasoning agent can carry your other saved agents as tools. When a task calls for one of them, the agent delegates mid-run: the sub-agent does its work and hands the result back, all inside the same run.

To set it up:

  • Open the agent in the agent editor and find the Sub-agents section. It appears on core and reasoning agents.
  • Choose Add a sub-agent and pick from your saved agents. Each attachment pins the sub-agent’s version, so a later edit never changes a supervisor silently.
  • Save. Studio validates the arrangement when you save: cycles are rejected and delegation depth is bounded, so a chain of supervisors cannot loop or run away.

When a run delegates, the Trace shows the hand-off as nested rows: the sub-agent’s name, status, duration and credits. The supervisor’s node on the canvas shows who it delegated to, and the run’s replay shows the same tree afterwards. Sub-agents can delegate in turn, and deeper calls indent further.

Sub-agent delegation happens between your own agents inside one run. To hand work to an agent outside SMELT, use Custom A2A instead. Available on Pro and Business plans.

Memory

A core or reasoning agent can remember across runs. Switch on Memory in the agent editor and the agent gets a remember tool: when it judges a fact worth keeping - a preference, an outcome, a correction - it saves a short note. On later runs, the most relevant notes are shown to the agent before it starts.

You stay in control. The Memory section lists everything the agent has kept, newest first; remove any entry, or clear the lot. An agent keeps at most 200 notes of up to 500 characters; when full, the least recently used note makes room. Deleting the agent deletes its memories.

Memory is what the agent learned; the Knowledge Base is what you gave it. Available on Pro and Business plans.

Managed AI vs BYOK

Every agent block supports two model modes:

  • Managed AI - SMELT provides the model. Usage is metered and included in your plan. No API key needed.
  • BYOK (Bring Your Own Key) - connect your own OpenAI or Anthropic key. Calls go to your own account, your provider bills you directly, and those runs use no credits.

You can mix modes across blocks in the same workflow. Set the default in project settings, override per block.

Next steps

  • Execution & Monitoring - run workflows and track progress in real time.
  • Integrations - connect the accounts your integration blocks act on.
  • Approval Gates - add human-in-the-loop checkpoints to workflows.
  • Auto Agent - how it plans into the planner-as-orchestrator pattern.
  • Custom A2A - delegate to agents outside SMELT over the open A2A protocol.