How AI agent automation works: an agent is 5 parts, a team is 3 more

"AI agents" are everywhere right now, and most explanations are either marketing or a research paper. This post is neither. It takes apart how agent automation works in practice, using AWFlow (the browser automation tool I build) as the example: what an agent is made of, what a team adds, and what happens between "here's my goal" and "here's your answer".

Part 1: an agent is 5 parts

1. A model: the brain.
The language model that reads, reasons and decides the next action. In AWFlow each agent picks its own: a model running inside your browser, a local Ollama model, or a cloud model with your own API key. Different agents can use different brains: a big one for the agent that plans, small ones for narrow jobs.

2. Instructions: the job description.
Plain-language text: who it is, what it's for, how it should behave. Writing good instructions is most of the work. The tool can draft them from one sentence ("an agent that triages my inbox every morning") and you edit from there.

3. Memory: what it learned about you.
Facts that persist between chats: your name, your preferences, "Dana approves the invoices". Two design choices matter here. Memory is stored on your device. And every new memory is announced with an Undo, so nothing is learned silently. Saying "remember that…" stores it directly, without even a model call.

4. Skills: what it can do.
Skills are tools the model can call: search the web, browse in its own tab group, run one of your workflows, use tools from other apps (via MCP), or run on-device AI tasks like classifying an image. An agent with no skills can only talk; skills are what turn it into automation.

5. Rules: what it may do alone.
Every action the agent wants to take is checked: allowed, ask first, or blocked. Some categories (paying, entering credentials, sending, deleting) always ask, whatever the preset. The important part: rules are enforced in code around every tool call, not written in the prompt. A web page that says "ignore your instructions" can't talk the agent out of them.

Part 2: a team is 3 more

One agent with many skills gets confused. A few focused agents with clear roles work better, if they're organised. A team adds:

1. Members with roles. "Researcher: gathers sources." "Writer: drafts." "Lead: splits the work and checks the result."

2. A way of working.

• Lead routes: the lead plans, delegates and merges.
• Pipeline: members run in a fixed order, each getting the previous result.
• Open table: you @mention who should answer.

3. Limits. Handoffs follow a map (an agent can only delegate to the teammates you allowed), and each conversation has budgets for steps, handoffs and cloud tokens. Hitting one pauses the team with a reason instead of letting it run forever.

You don't have to design this from scratch: describe what you want ("plan a weekend trip", "research a topic and turn it into posts") and Suggest a team proposes members, roles and a way of working, or start from a template.

Part 3: from goal to answer

Here's what happens when you type "Compare these 3 laptops and tell me which one to buy" to a lead-routes team:

You ──goal──▶ Lead
               │ plans: "research specs & prices", "summarize trade-offs"
               ├─delegate──▶ Researcher ── browses in its own tab group ──▶ findings
               └─delegate──▶ Writer ── turns findings into a recommendation ──▶ draft
Lead ◀── merges, checks ── one answer ──▶ You
          (any risky action: "Allow?" card waits for you)

Three details make this trustworthy rather than just impressive:

• Each handoff carries the task and the context it needs, not the whole conversation, so small models keep up and cloud bills stay small.
• Team rules can only make a member stricter. A permissive agent in a careful team becomes careful.
• Everything is logged in an Activity view: what each agent did, which tools it used, and what's waiting for you.

Part 4: from one-off to routine

Agents shine for one-off, messy tasks. But you can also give an agent a routine ("every morning at 8, check these pages and send me what changed"). A routine is an ordinary workflow, a trigger followed by a "Run agent" step, so you can open it and edit it like any other automation. That's where the two ways to automate meet.

When to use agents (and when not)

• Agents: the steps differ each time, the input is messy, you'd rather describe than design.
• Workflows: you can name the steps, it runs often or unattended, you need the same result every time. See the companion post.

Try it

Agentic Workflow (AWFlow) runs in your browser, on the model you choose, free and with no account needed to start. Intall it from the chrome store here.

Companion post: what a workflow really is, and why it's honest no-code