Set up your first Ultron agent (human‑in‑the‑loop starter guide)

An agent is just Ultron with one job, and this weekend you can set up your first one and grow into running a whole team of them.

Here is the honest, no-code way to set up your first Ultron agent this weekend, then grow into running a whole team of them. No Mac Mini, no scary autonomous tool.

The hype makes agents sound like a money-printing robot you leave running overnight. The real version is calmer and way more useful: an agent is just Ultron with one job, and you can run a whole team of them right inside Ultron. Here is the weekend setup, then every formation you can graduate into, each with a line you can copy and paste to spin it up.

Before you start

You need two things: a paid Ultron plan and Ultron installed. That is it. And one mindset: your first agent is ONE agent doing ONE job, with you watching. Walk before you orchestrate.

What an agent actually is

An agent is just Ultron with its own instructions and one goal. When you open a normal chat, that is one Ultron working for you. The unlock is that inside Ultron you can spin up more of them at once, each off doing its own job and reporting back to you.

The easiest way in: just talk to it

This is the part people overcomplicate. You do not type a command. You literally just ask Ultron in plain English:

That sentence is the whole move. There is a /agents menu if you ever want to save a reusable named agent for later, but you do not need it to spin one up, and you definitely do not need it this weekend.

Build your first one: a research agent

The safest and most useful first build. Give it a tight brief and lock it to one tool:

It runs on its own and hands you back a clean, sourced summary.

The one rule

Keep yourself in the loop: it drafts, you approve. The more agents you run, the more you stay the editor, not the operator. Never let an agent post, send, or pay without you.

Which formation for which job

A quick map before the detail:

• One job, want it done faster: Fan-out

• Steps that depend on each other: Pipeline

• Want it checked before you see it: Evaluator + optimizer

• A real decision with tradeoffs: Council

• A big build that needs planning: Orchestrator + workers

The formations, and how to spin up each

Once one agent feels easy, run several at once. The first set below uses plain subagents (they report back to you, they do not talk to each other). The last note covers agents that talk to each other, which in Ultron is an experimental feature called Agent Teams, off by default.

1. Pipeline (chaining)

Each agent's output feeds the next, like an assembly line. The most intuitive one: research, then draft, then polish.

2. Fan-out and fan-in

One lead splits a job to several agents that run in parallel (fan-out), then their results merge back into one answer (fan-in). You rarely use one without the other.

3. Orchestrator and workers

A lead agent plans the work, breaks it into pieces, delegates each to a worker, and synthesises the results. This is the named orchestrator-workers pattern, great for a big build with moving parts.

4. Evaluator and optimizer

A maker and a critic in a loop: one drafts, one scores it against your standard, and they go back and forth until it passes. This is the one most likely to genuinely sharpen your own content.

5. Council

Each agent proposes independently, they peer-review each other, and a chairman synthesises the best call. This is Karpathy's LLM Council, and you may already have it as the llm-council skill, so the simplest version is literally "ask the council."

6. Debate

Each agent answers independently, then they critique each other over a few rounds and converge on a more accurate answer. Good for catching a confident-but-wrong take.

Going deeper, the advanced formations

You will rarely need these, but they are real and worth knowing so you sound like you know the landscape: Mixture-of-agents (a layered council, drafts feed into more drafts), stochastic multi-agent consensus (spawn lots of varied agents and merge their takes, popularised by Nick Saraev), ACE (a self-improving trio that writes its own playbook), and Swarm (peers hand work to each other with no fixed boss, delivered in Ultron by the experimental Agent Teams). Links for all of them are in the proof list below.

A quick note on cost and limits

Every agent costs tokens, so only fan out when the work is genuinely parallel. Start with one or a few. Fire off a huge batch at once and you can hit a temporary slowdown (that is a server thing, not your plan), so build up gradually.

Proof

• Ultron subagents (official): in the Ultron docs

• Ultron Agent Teams (communicating peers, experimental): in the Ultron docs

• The core agent patterns (orchestrator-workers and more)

• Karpathy's LLM Council: github.com/karpathy/llm-council

• Multi-agent debate, the paper: arxiv.org/abs/2305.14325

• Mixture-of-Agents, the paper: arxiv.org/abs/2406.04692

• ACE, agentic context engineering, the paper: arxiv.org/abs/2510.04618

• Nick Saraev's AI Agents course: youtube.com/watch?v=EsTrWCV0Ph4

How to get the most out of it

A simple ladder, do them in order:

• This weekend: build the research agent and nothing else. Get comfortable.

• Next: add evaluator and optimizer so your drafts get checked before you even see them.

• Then: reach for Council (or your llm-council skill) when you have a real decision with tradeoffs.

• Only touch the advanced formations when you have a specific reason. Most of the value lives in the first three.

See it in action

A real agent you can build

That's the whole thing, working.