Dev Days 2026Hyderabad

Stop prompting, start orchestrating

Building AI agent teams with terminal coding agents

Who's talking

Bharadwaj
Pendyala

Tech Lead at Salesforce. I work on enterprise workflow systems and the tooling around agents.

I use several coding agents together in my daily work.

Today

The plan for the next 35 minutes

01What an agent is02Why one prompt stops scaling03The agent team workflow04Two modes: you in the loop, or idea to PR05Live demo06Try it yourself

No setup needed to follow along. Links at the end.

Part 1 / Words first

Six words for today

Prompt

One instruction you type to an AI.

Agent

An AI that reads files, runs commands, and checks its work until a task is done.

Spec

A short plan: what to build, and how we will know it works.

Review

A second opinion on the work, like a teammate reading your code.

Orchestrate

Give each agent a job and decide the order the work moves in.

Loop

Build, review, fix, review again. Repeat until the reviewer agrees.

Part 1 / What an agent is

An agent works in a cycle

01Read the task
→
02Pick one step
→
03Use a tool
→
04Check the result
↺

Like running a notebook cell, reading the output, and choosing the next cell. The agent repeats until the task is done.

Part 2 / One prompt at a time

Today, you are the loop

One prompt at a time

You carry every step

  • You ask, read, and spot the mistake.
  • You paste the error back in.
  • The same AI checks its own work.
An agent team

You make the decisions

  • You approve the plan.
  • Agents build, review, and fix.
  • You approve what ships.
Part 2 / Side by side

Prompting compared with orchestrating

PromptingOrchestrating
Who moves the workYou, every stepThe agents, between your decisions
Where the plan livesIn your headIn a spec file every agent can read
Who checks the workThe same AI, then youTests, a second agent, then you
Your jobTyping the next promptApproving the plan and the result
Part 3 / The idea

What if agents worked as a team?

One builds. Another reviews. You decide what ships.

Part 3 / The roles

Every team needs roles

Lead

You

Say the idea. Approve the spec and the result.

Builder

Claude Code

Drafts the spec, writes the code, runs the tests, and runs the loop.

Reviewer

Codex

Reads the change and argues against it. Never edits.

Coordinator

Herdr

Runs the agents side by side and shows who is working.

Start with the roles. Any terminal agent can fill any of them.

Part 3 / The tools

The tools at a glance

ToolWhat it isGet it
Claude CodeAnthropic’s coding agent for the terminalnpm install -g @anthropic-ai/claude-code
Codex CLIOpenAI’s coding agent for the terminalnpm install -g @openai/codex
HerdrRuns several terminal agents side by sideherdr.dev

Each agent needs an account with its provider.

Part 3 / A second opinion

Why a different agent reviews

  • The builder shares its own blind spots when it checks its own code.
  • A different agent, on a different model, starts fresh and has nothing to defend.
  • The reviewer only reports. It never edits, so each change has one owner.

Same reason people review each other’s code. The second reader only has to be different.

Part 3 / How the work moves

Build, review, repeat

The build and review loopFour stages from left to right. Claude Code turns your idea into a spec, and you approve it. The builder, Claude Code, implements and tests. The reviewer, Codex, reads the change and gives a verdict. If it requests changes, the feedback returns to the builder automatically, for at most three rounds. If it approves, you decide whether to open the pull request.HumanAgentsHuman01 · PlanIdea becomes a specClaude drafts what tobuild and how to test it.You approve the spec.02 · BuildClaude CodeWrites the code andruns the tests.03 · ReviewCodexReads the change againstthe spec. Gives a verdict.04 · DecideApproved workYou read the change andopen the pull request.You approve what ships.Request changes: feedback goes back to the builder automaticallyAt most 3 rounds, then it stops and asks you.
Part 3 / Step 1 · Plan

Write a spec the agents can check

.agent-team/spec.mdworked example
# Export tasks to CSV
Goal: a user can download their tasks as a CSV file.

In scope:     an "Export CSV" button. Columns: title, done.
Out of scope: filters, Excel format, scheduled exports.

Done when:
- The file opens in Excel or pandas, one row per task.
- A title with a comma stays in one cell.
- The existing tests still pass.

Out of scope tells the builder what not to add. Done when tells the reviewer what to check.

Part 3 / Before the build

One file of house rules for every agent

  • How to run the app and the tests.
  • Code style and naming.
  • What must never change.

One AGENTS.md, read by every agent. Write it once per project.

AGENTS.mdworked example
# House rules
Run:   npm start
Test:  npm test  # must pass before review

- Keep changes inside the spec.
- Match the existing code style.
- Never change the database schema
  without asking.
Part 3 / Step 2 · Review

Claude briefs the reviewer

.agent-team/review-request.mdwritten by Claude
You are the reviewer. Do not edit any file.
Read .agent-team/spec.md, AGENTS.md and git diff main...HEAD.
Check the change does what the spec says, and nothing more.
For each problem, give the file, the line, and the problem.
End with exactly one line:
VERDICT: APPROVE  or  VERDICT: REQUEST CHANGES

A fixed verdict line lets Claude decide the next step without you.

Part 3 / The coordinator

One screen, many agents

  • One tab per feature.
  • Builder and reviewer side by side.
  • Live status for every agent.
  • Each feature on its own branch, in its own copy of the repo.
A Herdr workspaceA simplified Herdr window. A sidebar lists two agents with their status: Claude Code working and Codex waiting. The main area shows one tab for the feature, with the builder pane on the left and the reviewer pane on the right.tab: csv-exportAGENTSClaude CodeworkingCodexwaitingBUILDER$ claudereading spec.mdediting the exportrunning testsREVIEWER$ codexwaiting for thebuilder to finish
Part 3 / Setup

One command starts the team

Claude Code, in a Herdr paneskill
# human in the loop: stops for the spec and the PR
/herdr-demo "Let me export my tasks to a CSV file."

# autonomous: idea in, draft PR out
/herdr-demo "Add a search box that filters tasks." --auto

Claude makes a worktree, opens Codex to its right, and runs the loop. You show up at the gates.

Part 3 / Inside the skill

What is inside /herdr-demo

  • A skill is one markdown file Claude loads when you type its name.
  • The description says when to use it. The body says what to do.
  • The skill lives in the repo, next to the code it works on.

About 75 lines. No framework, no SDK.

.claude/skills/herdr-demo/SKILL.mdoutline
---
name: herdr-demo
description: Run an agent team on one idea
  inside herdr. Use for /herdr-demo "<idea>" [--auto]
---
## 1. Set up the lane    worktree, port, Codex pane
## 2. Plan               spec.md, gate 1
## 3. Build              code, Playwright tests, commit
## 4. Review with Codex  brief Codex, wait for VERDICT
## 5. Loop               fix and resend, max 3 rounds
## 6. Finish             app URL, gate 2, draft PR
## Rules                 never push main, never merge
Part 3 / Step 3 · Automate

Claude drives Codex through Herdr

what Claude runssimplified
# open a pane to the right and start the reviewer
herdr pane split <claude> --direction right
herdr pane run <codex> "codex --sandbox workspace-write"
# hand over the review, then wait for the verdict
herdr agent send <codex> "Read .agent-team/review-request.md. Round 1."
until grep -q '^VERDICT:' .agent-team/review-1.md; do sleep 3; done
# REQUEST CHANGES? fix, commit, send round 2. Max 3 rounds.

Claude writes the instructions. Herdr carries the message. A file carries the verdict back.

Part 4 / Two modes

Two modes, one loop

Human in the loop

You approve each gate

  • You approve the spec.
  • You can watch every round.
  • You open the pull request.

Start here. Use it for anything that matters.

Autonomous

Idea in, draft PR out

  • One sentence starts it.
  • The agent writes its own spec.
  • A draft pull request comes back.

For small, well understood changes.

Same tools, same loop. The difference is where it waits for you. A person still merges.

Part 4 / Safety rails

Where the automation stops

  • Human in the loop: you approve the spec and the pull request.
  • The loop stops after 3 rounds and asks you.
  • The reviewer reports. It never edits.
  • Each feature stays on its own branch. Agents never push to main or merge.
Part 5 / Live

DEMO

Both modes, live.

Part 5 / Replay

What you just saw

YouSaid the idea
→
Claude + youDrafted and approved the spec
→
Claude CodeBuilt and tested
⇄
CodexReviewed
→
YouDecided to ship

In human in the loop mode you approved two gates. In autonomous mode you only read the draft PR.

Part 6 / Honest limits

What can go wrong

They agree on the wrong thing

A wrong spec gets built and approved. Fix: you approve the spec.

The loop never ends

Each round costs time and money. Fix: stop after 3 rounds.

Scope creep

Agents add things nobody asked for. Fix: an out of scope list the reviewer checks.

Secrets and real data

Agents read what is in the folder. Fix: sample data, no production keys.

Part 6 / Next step

From one feature to several

  • A worktree is a second working folder for the same repo, on its own branch.
  • One feature, one worktree, one Herdr tab.
  • Get one loop working before you run three.
terminalgit
# one folder and branch per feature
git worktree add ../app-csv    -b feat/csv-export
git worktree add ../app-search -b feat/search
git worktree add ../app-dark   -b feat/dark-mode
Part 6 / For data folks

It works for data work too

SQL query

Spec: expected result

Name the output on a small sample table. The reviewer checks joins, nulls, and duplicates.

Notebook

Spec: same numbers

Turn cells into functions. The reviewer checks the outputs match before and after.

Pipeline

Spec: a quality check

Add a rule such as no negative amounts. The reviewer looks for the edge cases it misses.

Part 6 / Your turn

Start small tomorrow

  1. Ask for the plan before the code. Read it.
  2. Ask a different assistant to review the change against the plan.
  3. Paste the review back to the builder.
  4. When the manual loop works, automate the paste.

Do it by hand for a week. Then automate.

What comes next

Take the laptop out of the loop

AnyoneTypes an idea
→
GitHub ActionsStarts a clean machine
→
AgentsBuild, review, test, record
→
EngineerReviews the draft PR
Questions?

Thank you.

Arrow keys to navigate / N notes / F fullscreen