Code Velocity
Nástroje pro vývojáře

Codex subagenti: Zlepšení pracovních postupů vývoje AI

·7 min čtení·OpenAI·Původní zdroj
Sdílet
Diagram znázorňující více subagentů AI pracujících paralelně, orchestrovaných hlavním agentem Codex, se šipkami označujícími tok dat a distribuci úloh.

I would like to review the following points on the current PR (this branch vs main). Spawn one agent per point, wait for all of them, and summarize the result for each point.

  1. Security issue
  2. Code quality
  3. Bugs
  4. Race conditions
  5. Test flakiness
  6. Maintainability of the code

V tomto scénáři by Codex pravděpodobně spustil šest odlišných subagentů, z nichž každý by se specializoval na jeden z uvedených bodů revize. Poté, co každý agent dokončí svou analýzu, Codex by sestavil zjištění do jediné, strukturované zprávy, která by nabídla celkový přehled o požadavku na sloučení (pull request). To demonstruje efektivitu získanou distribucí pracovní zátěže mezi specializované AI entity.

## Správa a zabezpečení vašeho ekosystému subagentů

Efektivní správa a robustní zabezpečení jsou klíčové aspekty při práci se subagenty. Codex poskytuje nástroje a mechanismy pro dohled nad aktivitami subagentů a zajištění bezpečného provozu v jejich sandboxových prostředích.

V interaktivních CLI relacích mohou vývojáři použít příkaz `/agent` k přepínání mezi aktivními vlákny agentů, kontrole probíhajících procesů nebo řízení konkrétního subagenta. Tato podrobná kontrola umožňuje úpravy a monitorování postupu jednotlivých agentů v reálném čase. Můžete také explicitně požádat Codex, aby zastavil spuštěného subagenta nebo uzavřel dokončená vlákna, abyste spravovali zdroje a soustředili se.

Bezpečnost je prvořadá a subagenti dědí aktuální zásady sandboxu z hlavní relace Codexu. Tím je zajištěno, že jejich operace dodržují předdefinovaná bezpečnostní a přístupová pravidla. Když se objeví požadavky na schválení z neaktivních vláken agentů, zejména v interaktivních CLI relacích, Codex je inteligentně zobrazí uživateli. Překrytí pro schválení označí zdrojové vlákno, což vám umožní stisknout 'o' pro otevření a prozkoumání tohoto vlákna před učiněním informovaného rozhodnutí schválit, zamítnout nebo odpovědět na požadavek. To zabraňuje slepým schválením a udržuje dohled vývojáře.

Pro neinteraktivní toky nebo situace, kdy nelze zobrazit nové schválení, každá akce vyžadující nové schválení automaticky selže a Codex ohlásí chybu zpět rodičovskému pracovnímu postupu. Tento mechanismus zabezpečení zabraňuje neoprávněným akcím v automatizovaných kontextech. Dále Codex znovu aplikuje živé přepsání za běhu rodičovského tahu – jako jsou změny provedené prostřednictvím `/approvals` nebo příznaku `--yolo` – na spuštěné potomky, čímž zajišťuje konzistentní bezpečnostní postoje v celé hierarchii agentů. Pro pokročilé uživatele je také možné přepsat konfiguraci sandboxu pro jednotlivé [vlastní agenty](#defining-custom-subagents-for-tailored-tasks), což umožňuje jemné řízení jejich oprávnění, například označením agenta jako 'pouze pro čtení'.

## Definování vlastních subagentů pro přizpůsobené úlohy

Zatímco Codex poskytuje několik vestavěných agentů, jako je `default` univerzální záložní, `worker` pro úlohy zaměřené na spuštění a `explorer` pro průzkum kódu s velkým objemem čtení, skutečná síla systému subagentů spočívá v jeho rozšiřitelnosti. Vývojáři mohou definovat své vlastní **vlastní agenty** k řešení vysoce specializovaných požadavků a přizpůsobit chování AI jedinečným kontextům projektu.

Vlastní agenty jsou definovány pomocí samostatných souborů TOML. Tyto soubory lze umístit do `~/.codex/agents/` pro osobní agenty nebo `.codex/agents/` pro agenty s rozsahem projektu. Každý soubor TOML v podstatě funguje jako konfigurační vrstva, která umožňuje vlastním agentům přepsat nastavení, která by jinak byla zděděna z rodičovské relace. To zahrnuje kritické parametry, jako je použitý AI model, jeho úsilí při uvažování, režim sandboxu a dokonce i konfigurace specifických dovedností.

Každý samostatný soubor vlastního agenta *musí* definovat následující pole:

*   **`name`**: Jedinečný identifikátor agenta, který Codex používá při jeho spouštění nebo odkazování.
*   **`description`**: Lidsky čitelný popis, který pomáhá Codexu pochopit, kdy tohoto agenta nasadit.
*   **`developer_instructions`**: Základní soubor instrukcí, které určují chování a operační logiku agenta.

Volitelná pole jako `nickname_candidates`, `model`, `model_reasoning_effort`, `sandbox_mode`, `mcp_servers` a `skills.config` mohou být také zahrnuta. Pokud jsou vynechána, tato nastavení zdědí z rodičovské relace, což zjednodušuje konfiguraci, kde jsou výchozí hodnoty přijatelné. Pro osvědčené postupy v prompt engineeringu, které přímo ovlivňují instrukce agentů, se podívejte na zdroje jako [Codex Prompting Guide](/cs/codex-prompting-guide).

Pole `name` je definitivním identifikátorem pro vlastního agenta. I když shoda názvu souboru s názvem agenta je běžnou a doporučenou konvencí, pole `name` v souboru TOML je konečným zdrojem pravdy. Pole `nickname_candidates` je užitečným doplňkem pro uživatelskou zkušenost, umožňující Codexu přiřazovat spuštěným agentům čitelnější zobrazované názvy, což je obzvláště užitečné ve složitých scénářích s více agenty.

## Globální nastavení a pokročilá konfigurace subagentů

Kromě definic jednotlivých vlastních agentů nabízí Codex globální konfigurační nastavení pro správu celkového chování pracovních postupů subagentů. Tato nastavení se obvykle nacházejí pod sekcí `[agents]` ve vašem hlavním konfiguračním souboru, což nabízí centralizovanou kontrolu nad alokací zdrojů a provozními parametry.

Zde je přehled klíčových globálních nastavení subagentů:

| Pole | Typ | Povinné | Účel |
| :--------------------------- | :----- | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `agents.max_threads`         | number | No       | Omezuje počet souběžně otevřených vláken agentů. Pokud není nastaveno, výchozí hodnota je `6`.                                                                                                                         |
| `agents.max_depth`           | number | No       | Omezuje hloubku vnoření spuštěných agentů (kořenová relace začíná na 0). Výchozí hodnota je `1`. Zabraňuje rekurzivní delegaci za bezprostřední potomky pro správu spotřeby tokenů a latence. |
| `agents.job_max_runtime_seconds` | number | No       | Nastavuje výchozí časový limit na pracovníka pro úlohy `spawn_agents_on_csv`. Pokud není nastaveno, výchozí hodnota je `1800` sekund (30 minut).                                                                             |

Nastavení `agents.max_threads` s výchozí hodnotou `6` poskytuje ochranu proti nadměrné spotřebě zdrojů omezením počtu subagentů, které mohou pracovat současně. Nastavení `agents.max_depth` s výchozí hodnotou `1` je obzvláště důležité. I když hlubší vnoření může vypadat lákavě pro komplexní delegování, zvýšení této hodnoty může vést k významnému nárůstu spotřeby tokenů, latence a spotřeby lokálních zdrojů kvůli opakovanému rozšiřování. Obecně se doporučuje udržovat výchozí hodnotu, pokud není specifický rekurzivní delegační vzor absolutně nezbytný a pečlivě spravovaný.

Soubory vlastních agentů mohou také zahrnovat další podporované klíče `config.toml`, což rozšiřuje jejich konfigurovatelnost nad rámec pouhých povinných polí. Tento modulární a vrstvený přístup ke konfiguraci zajišťuje, že vývojáři mají jemnou kontrolu nad svými AI agenty, což jim umožňuje optimalizovat výkon, náklady a zabezpečení přizpůsobené jejich specifickým vývojovým potřebám. Pochopením a využitím těchto výkonných schopností subagentů mohou vývojáři posouvat hranice kódování s podporou AI a významně zlepšit své vývojové pracovní postupy.

Často kladené dotazy

What are Codex subagents and how do they enhance AI development workflows?
Codex subagents are specialized AI agents that can be spawned in parallel by a primary Codex instance to tackle complex, multi-faceted tasks. They significantly enhance AI development workflows by enabling the division of labor across different agents, each focusing on a specific aspect of a task. This parallel processing capability is particularly beneficial for computationally intensive or intricate operations like comprehensive codebase exploration, implementing large-scale multi-step feature plans, or conducting extensive code reviews. By distributing the workload, subagents help in accelerating development cycles, improving the quality of outputs, and managing complexity more effectively than a single agent could.
How does Codex manage the orchestration of multiple subagents?
Codex excels at orchestrating subagent workflows by managing the entire lifecycle from spawning new agents to consolidating their results. When a complex task is initiated, Codex can intelligently route follow-up instructions to the appropriate subagents, monitor their progress, and await the completion of all requested tasks. Once all subagents have finished their assignments and returned their respective outputs, Codex then aggregates these results into a unified, consolidated response. This seamless orchestration ensures that even highly parallelized tasks remain coherent and deliver a comprehensive solution, simplifying complex project management for developers.
What are the security considerations and controls for Codex subagents?
Security for Codex subagents is a critical aspect, with several mechanisms in place to ensure safe operation. Subagents inherently inherit the current sandbox policy of the parent session, ensuring a consistent security posture. For interactive command-line interface (CLI) sessions, approval requests stemming from inactive agent threads can be surfaced to the user, allowing for informed decisions before actions are taken. In non-interactive environments or when immediate approval isn't feasible, actions requiring new approval will fail, preventing unauthorized operations. Developers can also apply runtime overrides for sandbox and approval choices, and even configure individual custom agents with specific sandbox modes, such as 'read-only', for fine-grained control over their operational scope and access.
How can developers create and utilize custom agents within Codex?
Developers can define custom agents in Codex to tailor AI behavior to specific needs. This is achieved by creating standalone TOML configuration files under `~/.codex/agents/` for personal agents or `.codex/agents/` for project-scoped ones. Each TOML file defines a single custom agent and acts as a configuration layer, allowing developers to override default settings like model choice, reasoning effort, or sandbox mode. Essential fields such as 'name', 'description', and 'developer_instructions' are mandatory, guiding the agent's identity and core behavior. This flexibility enables the creation of highly specialized agents for unique development tasks, further enhancing the adaptability of the Codex system.
What global settings are available for managing subagent behavior in Codex?
Codex provides several global settings to manage subagent behavior, primarily located under the `[agents]` section in the configuration file. Key settings include `agents.max_threads`, which controls the maximum number of concurrent open agent threads (defaulting to 6); `agents.max_depth`, which limits the nesting depth of spawned agents (defaulting to 1 to prevent excessive recursion and resource consumption); and `agents.job_max_runtime_seconds`, which sets a default timeout for workers in `spawn_agents_on_csv` jobs (defaulting to 1800 seconds if not specified). These settings are crucial for balancing performance, resource usage, and control over complex agent workflows, helping developers prevent unintended fan-out and manage token consumption effectively.
What are the primary advantages of using subagents for complex tasks?
The primary advantages of using subagents for complex tasks within Codex lie in their ability to parallelize and specialize operations. By breaking down a large task into smaller, manageable subtasks and assigning each to a specialized agent, development teams can achieve significant speed improvements and higher quality outcomes. For instance, in a large codebase review, one subagent might focus on security vulnerabilities, another on code quality, and a third on performance bottlenecks simultaneously. This concurrent processing not only accelerates the overall task but also allows for deeper, more focused analysis in each area, leading to more robust and comprehensive solutions than a single, monolithic AI agent could provide.

Buďte v obraze

Dostávejte nejnovější AI zprávy do schránky.

Sdílet