Invite a friend, get 1 month of Pro freeHow it works

AI agent workflow: teams, parallel parts and flows

Split an AI agent workflow across several agents: a team with a manager and roles, a parallel team that ends in one PR, and flows that pass work along.

Solviera Teknoloji Updated: 7 min read

When people think of an AI agent workflow, most picture one agent, one long task and a wait for the result. That works for small jobs. On something big, like “move payments to a new provider”, one agent researches, plans and implements all at once: context bloats, you never see a plan, and mistakes surface only after the code is written.

This post shows three ways AgentVera splits that work across several agents: a team with a manager and roles, a parallel team that runs independent parts at once, and flows that pass one agent’s output to the next.

Why split an AI agent workflow?

The problems with a single-agent session:

  • Context grows. Every file read during research stays in context during implementation.
  • The plan is invisible. The agent decides what to do and goes straight to coding.
  • Mistakes show up late. A wrong assumption only appears when the tests fail.

Several agents with clear jobs fix this. A researcher doesn’t write code, a planner only writes the plan, a developer implements it and a reviewer checks it. Each works with its own small context.

Option 1: a team with a manager and roles

The team view turns the agents open in your workspace into a team. In the Team structure window you put them on an org chart: one becomes the manager, the others get a role, instructions, someone they report to and someone they hand their work to. A team holds up to 24 agents.

You don’t have to build it from scratch. Ready-made roles fill in a researcher, planner, developer, reviewer, tester and more; ready-made teams, such as the software team (tech lead, planner, developer, reviewer and tester), open the agents they need for you. The team and each role can carry their own MCP servers, so the tester starts with Playwright without you setting it up per agent.

Nothing starts when the team is built. You type the work in the box below and choose Give to the team. It goes to the manager, who splits it, hands it out and checks the results. The agents work it out through agent chat and a shared task list.

While it runs, the team view shows who is working on what, messages travelling between agents and where each task stands. Permission requests come to the attention bar above the chart, where you approve or refuse them in place. Status report asks the manager for a short summary; Interrupt all stops everyone.

This suits work where agents need to talk to each other: a planner asking the researcher a follow-up question, a reviewer sending a change back to the developer.

Option 2: a parallel team that ends in one PR

Some jobs split into independent parts: the API, the UI and the migration of a new feature, for example. A parallel team runs them at once.

An agent starts the team itself when a big change splits this way. It writes the parts, or gives only the goal and lets Claude Sonnet read the repository and plan them. Then:

  1. Each part goes to its own agent in its own worktree and branch, so agents never touch each other’s files. By default 3 run at once, at most 6.
  2. An agent ends with the [[TESLİM]] marker when it’s done, or [[YARDIM]] when it’s stuck. A stuck part waits for you: accept what it did, let it continue or skip it.
  3. Finished parts merge into an integration branch, and the project’s test command runs as the final check. If a merge conflicts or the check fails, an integration agent steps in.
  4. You open one pull request, or queue the branch for the merge queue.

This suits large changes where the parts don’t need to talk to each other, only to fit together at the end.

Option 3: flows that pass work along

When you want a fixed chain, build it in flows. The classic research, plan, build sequence looks like this:

StepAgentWhat it getsRule
ResearchResearcherThe goalNo code; report the current state and the options
PlanPlannerThe researcher’s last replyGoal, out of scope, files, steps, test strategy, acceptance criteria
ApprovalYouThe planHuman approval node
BuildBuilderThe approved planImplement the plan, run the tests

When an agent finishes its turn, its last reply is dropped into the connection’s message template ({{output}}) and sent to the next agent. If the next agent is busy, the flow waits for its turn to end. The nodes that make the chain safe:

  • Condition: move on only when the reply contains a phrase or matches a regex, so a question asked midway doesn’t trigger the next step.
  • Transform: send only the last code block or the first N lines.
  • Human approval: stop until you approve, from the app or from Telegram.
  • Wait and Notify: leave time between steps and get told about important ones.
  • Turn limit: pause a connection that loops.

The approval step matters most

Whichever option you pick, reading the plan before code is written is the most valuable moment. A wrong plan takes five minutes to fix there and hours once code exists. The issues most often caught:

  • A module that should stay out of scope sneaking into the plan.
  • Existing tests missing from the test strategy.
  • Step order, such as interface first, then implementation.

In a team, ask the manager to send you the plan before handing out the work. In a flow, put a Human approval node before the builder.

How to write a good goal

The first input is the goal you write. A good goal:

  • Describes the outcome: “Move the payment provider from X to Y without changing the current API contract.”
  • States the limits: “Don’t touch the invoicing module.”
  • Defines success: “Existing payment tests must pass, and add an integration test for the new provider.”

A goal like “improve payments” pushes every agent to read the whole codebase.

Which one should you use?

  • One agent: a one-file fix, a typo or a small style change. Splitting it takes longer than the work.
  • Team view: ongoing work where agents with different roles need to talk, ask and review each other.
  • Parallel team: a big change with independent parts that should end as one branch and one PR.
  • Flows: a fixed sequence you run again and again, with approvals and conditions in between.

Running long jobs while you’re away

You don’t have to sit at the computer while a long job runs:

  • Telegram notifications: approve a flow step from your phone, and reply to a notification to send text to that agent.
  • AgentVera mobile app: follow each agent’s chat, terminal and diff on iOS or Android and answer its permission requests.
  • Scheduled tasks: send an agent a message on a cron schedule, for example to start dependency research every morning.
  • Prevent sleep: the setting that keeps the computer awake while agents work stops overnight jobs from stalling.

Checklist

  • Does the goal describe the outcome and limits in one paragraph?
  • Does each agent have one clear job?
  • Will you see the plan before code is written?
  • Will the tests run before the work is called done?
  • Will you be notified when it ends?

Wrapping up

Splitting an AI agent workflow across agents makes them more predictable on big jobs: each context stays small, the plan is visible and mistakes surface early. AgentVera gives you three ways to do it, from a live team to a parallel run that ends in one PR.

Start on the free plan, and see notifications and approvals to handle approvals remotely.

Questions

Why several agents instead of one?

Research, planning, building and review are different jobs. Separate agents keep each context small, let you see the plan before code is written and catch mistakes early.

What is the difference between the team view and a parallel team?

The team view turns your open agents into a lasting team with a manager and roles that work together while you watch. A parallel team is an agent splitting one job into parts, running each part in its own worktree and merging them into one branch and one PR.

How do agents in a team pass work to each other?

Through agent chat: they send messages, wait for replies and share a task list with dependencies. Agents on different CLIs can talk to each other.

Can I still build a research, plan, build chain myself?

Yes, with flows. Put three agents on the canvas, connect them with message templates and add a Human approval node before the builder.

Bring your agents to one desk.

Download AgentVera for free; your installed CLIs are ready to go.

More posts