AI Agents and Orchestrators Manual
Autonomous Agents · Orchestration · Execution · Transformation
START ↓AI Agents and Orchestrators Manual is a practical guide to understanding and orchestrating AI agents.
Designed for discovery, learning, and training · Omninoun.com
2026 — Omninoun Cyberwork — The Manifesto V3
Artificial intelligence is no longer just a chatbot answering questions like ChatGPT or Claude. We are entering the era of execution.
AI becomes operational.
It no longer just advises, it acts. We are developing systems capable of making decisions, executing complex tasks, and learning from their mistakes.
The goal is to free humans from repetitive tasks to focus them on strategy and creation.
Most companies use AI in an isolated way: an employee copies and pastes text into an LLM, retrieves the result, and processes it manually. This is a waste of time and efficiency.
The true ROI of AI lies in global orchestration and automation of processes via connected workflows.
Our approach is based on the interconnection of four major technological pillars:
Strategic thinking and decision-making engines.
Workflow orchestration and data flows.
Long-term memory and targeted business context.
Connection to business tools (CRM, ERP, Slack).
We deploy concrete solutions to support this transformation:
Upskilling managers and teams to integrate AI into their operational daily lives.
An internal tool to structure perfect instructions and obtain optimal results without hallucinations, ensuring output reliability.
Our philosophy: technical rigor, refusal of superficial jargon, and implementation of robust architectures (Docker, Controlled Cloud, Sovereignty).
Moving from a reactive approach to an AI-augmented enterprise.
Before choosing a model, it must be understood that there is no universal "best model." There are profiles adapted to specific uses. Here is the taxonomy that structures this guide.
These models excel in generating interfaces: React components, Tailwind, animations, landing pages, clean HTML/CSS. They have a good sense of visual rhythm and produce quickly usable frontend code.
These models think before they act. They break down problems, identify edge cases, and propose solid structures. Excellent for complex debugging, refactoring, and architectural decisions.
These models are optimized for agentic flows: tool calling, execution loops, task chains. They know how to use tools, self-correct, and progress through several steps without constant supervision.
These models have been massively trained on code. They understand the nuances of frameworks, produce correct and consistent code, and handle multi-file projects well.
These models offer an exceptional quality/cost ratio. Perfect for repetitive tasks, high-volume pipelines, secondary agents, and data preprocessing.
These models handle contexts of several hundred thousand tokens. Essential for analyzing large codebases, long documents, or maintaining consistency over very long sessions.
For each model or use case, evaluate it on these 5 axes:
| Axis | What it Measures | Questions to Ask |
|---|---|---|
| Speed | Generation rapidity | Do I need immediate results? |
| Depth | Reasoning quality | Is the problem complex or simple? |
| Cost | Price per token/request | What is the frequency of use? |
| Autonomy | Agentic capability | Should it act alone or just answer? |
| Creativity | Originality of outputs | Is it creative or technical work? |
Using the same model for everything — because it's simple, because it's what you know — is the most common pitfall. It's also the most costly and least efficient in the long run.
Using GPT-5 to generate simple CSS is like taking a taxi to go buy bread.
Benchmarks measure performance under controlled conditions. They don't measure what matters: quality on your specific task, in your context, with your constraints. The best model is the one that finishes your work quickly, cleanly, with few retries.
False. Modern low-cost models (Gemini Flash, DeepSeek, Haiku) do 80% of the work of a premium model for 10% of the price. The real skill is knowing when to pay for power and when to save.
A technical and structured mapping of tools, environments, and protocols that define software engineering and automation based on autonomous agents.
Autonomous execution systems interacting directly with the code lifecycle (IDE, CLI, sandboxing environments, and Git).
| Agent | Technical Description | Official Link |
|---|---|---|
| Claude Code | Anthropic's native CLI agent running locally in the terminal. Capable of reading the codebase, running tests, managing Git, and exploiting MCP servers. | Visit Site |
| OpenAI Codex CLI | Command-line interface exploiting Codex/GPT models for translating natural commands into executable scripts. | Visit Site |
| Gemini CLI | Command-line tool allowing direct interaction with the Gemini API for refactoring and large-context code analysis tasks. | Visit Site |
| Cursor Agent | Advanced agent mode integrated into the Cursor IDE, capable of autonomously planning and applying multi-file modifications. | Visit Site |
| Windsurf | "Agent-native" IDE orchestrating real-time collaborative workflows between the developer and the agent (Cascade). | Visit Site |
| Aider | Command-line programming assistant optimized for Git, allowing code editing in existing repositories with strict commit tracking. | Visit Site |
| Goose | Agnostic open-source agent (Block/Agentic AI Foundation). Runs directly on the machine (CLI/Desktop) to automate build or refactoring recipes without Docker friction. | Visit Site |
| OpenHands | (Successor to OpenDevin). Open-source platform allowing autonomous software agents to modify code and execute commands in a secure Docker sandbox. | Visit Site |
| Amp | Coding agent developed by Sourcegraph, leveraging their global code intelligence engine and semantic repository indexing. | Visit Site |
| Freebuff | Open-source community alternative focused on local codebase modification. | Visit Site |
| Codebuff | Assistant specialized in navigation, refactoring, and rewriting of large-scale software projects. | Visit Site |
| Pi Coding Agent | Recent autonomous agent designed for resolving complex architectural tickets and generating unit tests. | Visit Site |
Cloud workspaces and IDEs where agents collaborate synchronously or asynchronously with the user.
High-level frameworks managing task distribution, memory, and multi-agent collaboration.
Agents specialized in DOM interaction, navigation, and automation of Web processes on behalf of humans.
Integration platforms connecting LLMs and agents to databases and third-party APIs via pipeline architectures.
Fundamental libraries and SDKs for developing custom cognitive architectures.
The standardized layer essential for structured communication between agents, servers, and clients.
| Protocol | Technical Role | Importance / Maturity |
|---|---|---|
| MCP (Model Context Protocol) | Open standard developed by Anthropic linking models to secure data sources (GitHub, Slack, SQL databases, Docker environments) via a unified API. | ⭐⭐⭐⭐⭐ |
| A2A (Agent-to-Agent) | Emerging specification allowing message routing, subtask delegation, and context negotiation between distinct autonomous systems. | ⭐⭐⭐⭐⭐ |
| ACP (Agent Communication Protocol) | Open standard for inter-agent messaging, ensuring formatting and integrity of distributed communications. | ⭐⭐⭐⭐ |
| OpenAPI Specification | Formal description of REST API endpoints allowing agents to dynamically generate HTTP requests without human intervention. | ⭐⭐⭐⭐ |
| JSON Schema | Strict definition of data structures (Input/Output). Crucial for constraining Structured Output of models and avoiding type analysis errors. | ⭐⭐⭐⭐ |
| OAuth 2.0 | Authorization delegation framework, ensuring that agents securely access third-party resources on behalf of the user. | ⭐⭐⭐⭐ |
| SSE (Server-Sent Events) | Unidirectional streaming protocol allowing real-time reception of token streams and agent execution logs. | ⭐⭐⭐ |
| WebSocket | Persistent bidirectional communication channel for real-time state synchronization and synchronous multi-agent collaboration. | ⭐⭐⭐ |
The word "agent" is everywhere. It is often misused. Here is the definition that matters operationally:
An AI agent is a model that can take actions in the real world — calling APIs, reading files, writing code, browsing the web, sending messages — and chain these actions autonomously to achieve a goal.
What distinguishes an agent from a simple chatbot:
An agent doesn't "answer" — it "does".
The most frequent confusion in AI projects is mixing two roles that must remain separate:
| Orchestration | Execution |
|---|---|
| Decides what to do | Does what is decided |
| Chooses the right agent for each task | Executes a specific task |
| Handles errors and redirects | Reports errors |
| Maintains the global vision | Maintains the local focus |
| Models: Claude Sonnet, GPT-5 | Models: DeepSeek, Haiku, Gemini Flash |
The classic error: using a powerful and expensive model for simple task execution. Result: exploding bill, unnecessary latency, no quality gain.
The right approach: lightweight model for execution, intelligent model for orchestration — and human for final supervision.
Before launching anything, you decompose. Practical example:
Goal: "Create a user profile page with photo, bio, and activity history"
Each step is clear, assignable, verifiable. That is agentic decomposition.
Routing is the real-time decision: "For this specific task, which model?"
Routing criteria:
A good routing system can automate these decisions. But even manually, developing this reflex changes everything.
Agents don't do everything right the first time. The strength is in the loop:
This loop short-circuits the "I send a prompt and hope" mental model. It replaces hope with control.
A major problem with agents: they forget. Most models do not have persistent memory between sessions.
Practical solutions:
Human supervision has a cost: your time and attention. It must be reserved for moments when it adds value.
| Supervise Actively | Let It Run |
|---|---|
| Irreversible decisions | Repetitive and tested tasks |
| First execution of a flow | Stable pipelines with logs |
| Public or client outputs | Internal preprocessing |
| Large amounts / sensitive data | Low-value classification / extraction |
| New agents / tools | Agents already validated on hundreds of cases |
The golden rule: supervise until you have confidence. Let go as soon as you have reliable quality metrics.
Giving an agent access to critical systems before validating its behavior on simple cases. Result: poorly executed irreversible actions.
Rule: always start in "read-only" mode, then grant permissions progressively.
Launching an agent on a long task without passing it the relevant history. It "forgets" the beginning, producing inconsistent outputs.
Rule: always include the minimum necessary context — neither too much (context pollution) nor too little (loss of consistency).
Using a premium model for all steps of a pipeline, including the simplest ones. Result: bill ×10 without quality gain.
Rule: profile each step, assign the cheapest model that does the work well.
"Do something interesting with this data." Agents don't handle ambiguity as well as humans. Result: random outputs, looping retries.
Rule: be as precise as you would be with a junior collaborator — expected format, constraints, examples if possible.
A pipeline that doesn't foresee what happens when an agent fails. It crashes, nothing continues.
Rule: always provide a fallback — another model, a degraded output, a human alert.
To move from theory to production without obstacles, implementing agentic thinking on your machine
(via your configuration files like CLAUDE.md or .clauderc) must follow a strict 6-step protocol.
This workflow transforms a simple chatbot into an autonomous and reliable software engineer.
Before any modification, the agent isolates itself in a planning node. It maps the tree structure, inspects dependencies, and lists impacted files. A written action plan is produced and submitted for validation before execution.
Before writing or modifying a single line of code, you must mandatorily open a planning phase. Analyze the existing tree, read the necessary files, and write a structured action plan in list form. Wait for my explicit validation before moving to execution.
To avoid context overload, the main agent delegates to specialized subagents. Each subagent handles a targeted task (tests, parsing, UI), ensuring precision and modularity.
For any complex task involving more than 3 files or distinct technologies (e.g., Frontend + Backend), behave like an orchestrator. Decompose the work and generate ultra-targeted instructions (micro-prompts) to guide your subagents or your own future iterations in an isolated way.
The agent rereads and critiques its own code before submitting it. It looks for security flaws, duplications, unnecessary complexity, and missing typings. Corrections are automatically applied in this short loop.
Once the code is written, apply an automatic critical review before presenting it to me. Analyze your own proposal for: security flaws, duplication (DRY), unnecessary complexity (KISS), and missing typings. Correct your own errors invisibly in this phase.
A task is only validated after executing unit tests and the production build. Without complete success, the task remains open.
You are formally prohibited from declaring a task as finished or asking me to test if you have not yourself executed the project's tests and the production build in the terminal. The success of these commands is the only acceptable validation criterion.
Code must remain simple, robust, and readable. No over-engineering or heavy frameworks if a native solution suffices. Elegance takes precedence over gratuitous complexity.
Constantly strive for elegance and architectural simplicity. Never propose over-engineering or heavy frameworks if a native or simple solution is suitable. The code must be minimal, modern, documented on the 'why', and human-readable.
In case of test or build failure, the agent analyzes the logs, isolates the bug, and proposes a fix. It restarts the modification loop without requesting human help, except for persistent blocking.
If a test or build command fails at step 4, do not interrupt your execution to ask me for help. Immediately analyze the terminal's error logs, locate the faulty line, issue a new hypothesis, and correct the course autonomously.
This guide is designed to be read and reread as you progress. Here is how to approach it based on your current level.
You are discovering AI models or have just started using them in your workflow.
You already use several models but intuitively, not yet systematically.
A simple agent that takes a React component specification, breaks it down into steps, and generates each part with the right model. Nothing complex — but it forces thinking in flows.
You master the basics and want to build robust agentic systems.
How to build a system that remains reliable as it gains autonomy? The answer: tests, metrics, logs, and progressive supervision.
| Level | Main Skill | Typical Setup | Next Step |
|---|---|---|---|
| 🟢 Beginner | Choosing the right model by use case | Gemini + Qwen + 1 premium | Apply a stack pattern |
| 🟡 Intermediate | Combining models, decomposing tasks | SaaS or Low-cost stack | Build a first simple agent |
| 🔴 Advanced | Orchestration, routing, robust pipelines | Economic Elite Setup | Multi-agent architecture with metrics |
Key terms in this guide, defined without unnecessary jargon.
To quickly choose the right model according to the situation:
| Situation | Recommended Model | Reason |
|---|---|---|
| Standard React/Frontend Framework component | Gemini Flash | Speed + frontend quality |
| Complex Backend API model | Qwen 3.6 Plus | Excellent Python/ORM |
| Inexplicable bug | GLM-5 or Claude Sonnet | Deep reasoning |
| Creative landing page | Kimi K2.5 | Visual creativity |
| Automated pipeline | DeepSeek V4 | Ultra-low cost, tool calling |
| Small CSS correction | Claude Haiku | Fast and cheap |
| Critical system architecture | Claude Sonnet / GPT-5 | Maximal intelligence |
| Long session (100k+ tokens) | Gemini or Claude | Large context |
| Massive multi-file refactoring | Claude Sonnet | Consistency over large context |
| High-volume test/classification | DeepSeek or Haiku | Volume + cost |
The AI model market is evolving fast. A model recommended today may be outdated in six months. A new competitor can emerge overnight.
This guide must be updated regularly. The principles (agentic thinking, orchestration, routing, stack patterns) remain stable. Specific model recommendations evolve.
Treat it as a living system: note your own observations, add your use cases, and invalidate what no longer corresponds to your reality.
The best guide is the one you adapt to your reality.