Skip to content
Ioannis Ouzounis

AI agent orchestration

One request. Many agents. One accountable answer.

When you bring me a problem, I don't ask an AI once and forward the reply. I brief a team of agents to explore it from different angles at the same time, have other agents try to tear the results apart, and review what survives myself. You get more options, checked harder, sooner.

Illustration
  1. Researcher

    how others solve this

    Done
  2. Mapper

    current process from sample files

    Done
  3. Designer A

    Dropped: spreadsheet template

    ↳ breaks when a column is renamed

    Rejected
  4. Designer B

    Python tool

    Survived
  5. Reviewer

    edge cases

    Needs attention
  6. Judge panel

    scoring

    Done
  7. Ioannis

    final review

    Approved

What's an AI agent, in plain words?

An AI agent is an AI assistant with one specific job, the tools to do it and clear instructions: research this, design that, test this claim. On its own, an agent is fast and fallible. The value comes from coordination: many agents with different jobs, checking each other, under someone who knows what good looks like.

Exploring options used to be the expensive part

In a traditional engagement, every option costs consultant hours, so you hear about one or two, usually the ones the consultant already knows. Coordinated agents change that math. Researching an approach, drafting a solution or testing an edge case takes minutes, and many of these run at the same time. You see more options, sooner, without paying for every detour. And because building gets cheaper too, smaller tasks that were never worth automating can now pay for themselves.

How I run a request

  • AI agents
  • Human checkpoint
  1. 01 Brief

    What happens
    We agree on the problem, the constraints, the decision criteria and the data rules, on one page. I turn that into precise instructions for each agent.
    Why it matters
    An agent is only as good as its brief. A vague brief produces confident nonsense.
    You get
    A one-page brief you approve before anything runs.
    In localization terms
    The project brief, glossary and style guide every translator works from.
  2. 02 Fan out

    What happens
    Several agents work at the same time, each with a different assignment: how others solved this, the simplest option, the most robust option, the edge cases, the effort and running costs. Each works from its own brief and never sees the others' drafts. I supervise them live in my own monitoring tool.
    Why it matters
    You see genuinely different approaches, not five versions of the first idea.
    You get
    Nothing yet. This is where breadth is created.
    In localization terms
    A large job split across translators who share one glossary.
  3. 03 Challenge

    What happens
    Separate agents are told to refute the results: find the flaw, the missing case, the claim without a source, the hidden cost, the data risk. Anything testable is tested on sample files. Then a panel of judge agents, each weighing a different priority such as cost, risk or effort, scores the survivors against the criteria from the brief.
    Why it matters
    Agents make mistakes. No agent checks its own work. Weak ideas die here, not in your inbox.
    You get
    Still nothing. Only what survives moves on.
    In localization terms
    Revision and the quality scorecard. Translation quality standards such as ISO 17100 require a second linguist, never the translator, to revise the translation. I apply the same rule to agents.
  4. 04 Decide

    What happens
    I read the evidence, not just the summaries, rerun what matters and make the call. I add what agents can't know: how your team really works, what your clients will tolerate, what will still make sense in a year. Where agents disagree, you see both sides.
    Why it matters
    Judgment and accountability stay with a person.
    You get
    A recommendation I'm accountable for.
    In localization terms
    The language lead's sign-off before a release goes to a critical market.
  5. 05 Deliver and measure

    What happens
    A short recommendation, ranked alternatives with trade-offs, risks and effort, and an appendix of the options explored and why each was dropped. If you want, I build it, and for automations we measure the task before and after.
    Why it matters
    You decide with the options on the table, not just my favorite, and savings become numbers, not promises.
    You get
    The deliverable, plus before-and-after figures for anything we automate.

Reviewed by IoannisIO

Why this produces more options, and better ones

  • Breadth without the wait

    Agents work in parallel, so exploring several directions takes about as long as the slowest one, not the sum of all of them.

  • Different on purpose

    Every agent gets a different angle and never sees the others' drafts, which breaks the “first idea wins” habit.

  • Cheap to explore, quick to reject

    An extra option costs minutes, not days. Most ideas don't survive the challenge round. That's the point: your time goes only to the ones that did.

  • Errors caught early

    Adversarial review catches invented facts, missing cases and shaky assumptions before they reach you.

  • One mind holding the thread

    I write every brief and read every verdict, so nothing is lost in handoffs between people.

  • An honest limit

    My review is the bottleneck, by design. If I can't verify it, it doesn't ship.

IllustrativeHow a run narrows down. Illustrative counts, not taken from a real run.
  1. Explored20

  2. Survived the challenge6

  3. On your shortlist3

  • Option
  • Dropped in review
  • Your choice

Illustrative example, not a client case

What a run looks like

Illustrative
  • AI agents
  • Human checkpoint
  • Dropped in review

The request

“Every Monday, two people spend the morning merging client spreadsheets into one status report. Mistakes slip through about once a month.”

  1. 01 Brief

    One accurate report by 10:00 every Monday, run by the team without a developer, no client data uploaded to new services, no silent errors.

  2. 02 Fan out

    One agent maps the current steps from sample files. One researches existing tools and connectors. Three draft different fixes: a spreadsheet template with formulas, a Python script with a simple interface, and a scheduled workflow that runs on its own. One hunts for edge cases: renamed columns, merged cells, empty rows, mixed date formats.

  3. 03 Challenge

    Reviewers find that the template breaks as soon as a client renames a column, and that the scheduled workflow needs a paid connector and puts client data in a new cloud service. Both are dropped, and the reasons go in the appendix.

    1. Dropped: A spreadsheet template with formulas

      Reviewer

      Breaks when a column is renamed.

    2. A Python script with a simple interface

      Survived

    3. Dropped: A scheduled workflow that runs on its own

      Reviewer

      Puts client data in a new cloud service.

  4. 04 Decide

    I test the Python script on real sample files, add a validation step that stops the run and explains any mismatch, and confirm it fits how the team works on Mondays.

  5. 05 Deliver and measure

    The team runs it every Monday. We time the task before and after and count the mistakes that no longer slip through.

Reviewed by IoannisIO

What the agents do. What I do. What you decide.

The agents

  • Research and summarize
  • Map processes from your sample files
  • Draft alternative designs, code and documentation
  • Generate test cases and edge cases
  • Attack each other's assumptions
  • Score options against your criteria

Me

  • Frame the problem and write every brief
  • Set the scoring criteria with you
  • Verify the evidence and rerun key tests
  • Review and test the code that ships
  • Talk to your team
  • Answer for the result

You

  • Approve the brief and the data rules
  • Choose among the final options
  • Sign off before anything touches live systems

AI drafts. I decide.

  • Nothing reaches you that I haven't read, checked and can explain.
  • Claims need evidence: a source, a test run or a sample output. Facts are checked against sources or tests, never against another AI's confidence. Anything unverified is labeled as such.
  • Disagreements between agents are shown to you, not smoothed over.
  • Code is tested and reviewed like any other code before handover. Every automation includes validation checks and a manual fallback.

What I never hand to AI

  • The decision about what to build
  • Anything sent to you without my review
  • Savings figures: those come from measurements, not models
  • Your confidential data outside the rules we agreed

Your data, under your rules

Localization runs on confidential files and NDAs. I treat AI work the same way.

These are the default rules I work to. The exact rules for your project are agreed in writing before any agent runs.

  • Data rules in writing

    Before any run, we agree which data the agents may see. Anything off-limits stays off-limits.

  • Samples, not secrets

    Wherever possible, agents work on anonymized or synthetic samples instead of your real files.

  • Tools and access agreed up front

    The written rules name the AI services that may see your data, the access I get and how long project data is kept.

  • Confidentiality first

    If you need an NDA, we agree on one before you share any details.

Many agents need supervision. So I built mine.

My agent monitor is a VS Code extension I designed, built and test myself. It lists every running agent session across all my editor windows, shows its state (working, waiting for my input, needs attention) and its current activity, and jumps to it in one click. A pinned panel floats above everything else, and a sound tells me when an agent finishes and is waiting for me. Before it touches any configuration, it makes a timestamped backup, and uninstalling restores it.

I'm careful with automation that touches other people's systems. I'm just as careful with my own.

TypeScript · automated tests · version 0.0.24 · built for my own daily work

IllustrationA sketch of the monitor panel, with made-up sessions.

Agent monitor

Pinned

  • Mapper

    reading sample files

    Working

  • Designer B

    asks which date format wins

    Awaiting prompt

  • Reviewer

    found merged cells in two files

    Needs attention

  • Researcher

    connector comparison ready

    Done

How this compares

  • An agency

    Breadth
    Several people, with handoffs between them.
    Checking
    Thorough.
    Accountability
    Spread across several people and several invoices.
    Speed and cost
    Slow to start and expensive to change course.
  • AI tools on your own

    Breadth
    One answer at a time, from one angle.
    Checking
    Nobody checks the output. Wrong answers look exactly as convincing as right ones.
    Accountability
    Nobody owns the result.
    Speed and cost
    Fast and cheap.
  • Working with me

    Breadth
    The breadth of a team, from parallel agents.
    Checking
    Verification built into every step.
    Accountability
    One accountable expert, from brief to handover.
    Speed and cost
    More options, sooner, without paying for every detour.

Questions that deserve more than one answer

  • “Our handoffs between project managers, vendors and QA are a mess. What are our options?”
  • “Which translation management system or integration fits our volume and budget?”
  • “Releases keep slipping. Where is the time actually going?”
  • “Which of our manual tasks should we automate first?”
  • “Give us three ways to build this feature, with the trade-offs.”
  • “How do we clean, convert or check thousands of files without doing it by hand?”

Questions people ask

Isn't this just ChatGPT with extra steps?

A single chat gives you one answer, from one angle, unchecked. This gives you several independent approaches, a deliberate attempt to break each one, scoring against your criteria and a human sign-off. The extra steps are the point.

Will the AI make mistakes on my project?

Agents do make mistakes. That's why no agent checks its own work, and why I review everything before it reaches you. The process is built to catch errors, not to pretend they don't happen.

Do I need to understand AI to work with you?

No. Describe the problem in your own words. You get a recommendation in plain language, with the technical detail in an appendix for whoever needs it.

What if the best answer isn't AI at all?

Then that's my recommendation. The winning option is often a small script, a better template or a feature in a tool you already pay for. The agents explore; they don't sell AI.

How many agents work on my request?

As many as the problem needs. A narrow question might need a handful; an open design problem gets more. What matters is that each one has a distinct job and every result gets checked.

Which AI tools do you use?

Whatever fits the problem and your constraints, and the written data rules say which ones may see your data. If your company has approved AI tools, I work within them.

What does it cost?

It depends on the size of the question. Describe it, and I'll tell you whether an options sprint fits and what it would involve before any work starts.

Have a question that deserves more than one answer?

Send it over. I'll tell you whether an options sprint fits and what you'd get back.

I read and answer every message myself.