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:
- 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.
- 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. - 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.
- 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:
| Step | Agent | What it gets | Rule |
|---|---|---|---|
| Research | Researcher | The goal | No code; report the current state and the options |
| Plan | Planner | The researcher’s last reply | Goal, out of scope, files, steps, test strategy, acceptance criteria |
| Approval | You | The plan | Human approval node |
| Build | Builder | The approved plan | Implement 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.