Vull revisar els següents punts de l'actual PR (aquesta branca vs main). Genera un agent per cada punt, espera que tots finalitzin i resumeix el resultat de cada punt.
- Problema de seguretat
- Qualitat del codi
- Errors
- Condicions de carrera
- Inestabilitat de les proves
- Mantenibilitat del codi
En aquest escenari, Codex probablement llançaria sis subagents diferents, cadascun especialitzat en un dels punts de revisió esmentats. Després que cada agent completés la seva anàlisi, Codex recopilaria les troballes en un informe únic i estructurat, oferint una visió holística de la sol·licitud d'extracció. Això exemplifica l'eficiència obtinguda en distribuir la càrrega de treball entre entitats d'IA especialitzades.
## Gestió i seguretat del vostre ecosistema de subagents
La gestió efectiva i la seguretat robusta són consideracions clau quan es treballa amb subagents. Codex proporciona eines i mecanismes per supervisar les activitats dels subagents i garantir operacions segures dins dels seus entorns aïllats (sandboxed).
En sessions CLI interactives, els desenvolupadors poden utilitzar l'ordre `/agent` per canviar entre fils d'agent actius, inspeccionar processos en curs o dirigir un subagent en particular. Aquest control granular permet ajustos i supervisió en temps real del progrés de cada agent. També podeu demanar explícitament a Codex que aturi un subagent en execució o que tanqui els fils completats per gestionar els recursos i el focus.
La seguretat és primordial, i els subagents hereten la política de sandbox actual de la sessió principal de Codex. Això garanteix que les seves operacions s'adhereixin a les regles de seguretat i accés predefinides. Quan sorgeixen sol·licituds d'aprovació de fils d'agents inactius, especialment en sessions CLI interactives, Codex les mostra de manera intel·ligent a l'usuari. Una superposició d'aprovació indicarà el fil d'origen, permetent-vos prémer 'o' per obrir i inspeccionar aquest fil abans de prendre una decisió informada d'aprovar, rebutjar o respondre a la sol·licitud. Això evita aprovacions cegues i manté la supervisió del desenvolupador.
Per a fluxos no interactius o situacions en què no es pot mostrar una nova aprovació, qualsevol acció que requereixi una nova aprovació fallarà automàticament, i Codex informarà de l'error al flux de treball pare. Aquest mecanisme a prova de fallades impedeix accions no autoritzades en contextos automatitzats. A més, Codex reaplica les anul·lacions de temps d'execució en viu del torn pare —com ara els canvis realitzats mitjançant `/approvals` o la bandera `--yolo`— als fills generats, garantint postures de seguretat coherents en tota la jerarquia d'agents. Per als usuaris avançats, també és possible anul·lar la configuració del sandbox per a [agents personalitzats](#defining-custom-subagents-for-tailored-tasks) individuals, permetent un control precís sobre els seus permisos, per exemple, marcant un agent com a 'només lectura'.
## Definició de subagents personalitzats per a tasques a mida
Si bé Codex proporciona diversos agents integrats, com el `default` per a propòsits generals, el `worker` per a tasques centrades en l'execució i l'`explorer` per a l'exploració de bases de codi amb molta lectura, el veritable poder del sistema de subagents rau en la seva extensibilitat. Els desenvolupadors poden definir els seus propis **agents personalitzats** per abordar requisits altament especialitzats, adaptant el comportament de l'IA a contextos de projecte únics.
Els agents personalitzats es defineixen utilitzant fitxers TOML independents. Aquests fitxers es poden col·locar a `~/.codex/agents/` per a agents personals o a `.codex/agents/` per a agents amb àmbit de projecte. Cada fitxer TOML actua essencialment com una capa de configuració, permetent als agents personalitzats anul·lar la configuració que altrament s'heretaria de la sessió pare. Això inclou paràmetres crítics com el model d'IA utilitzat, el seu esforç de raonament, el mode de sandbox i fins i tot configuracions d'habilitats específiques.
Cada fitxer d'agent personalitzat independent *ha de* definir els següents camps:
* **`name`**: L'identificador únic de l'agent, que Codex utilitza en generar-lo o referenciar-lo.
* **`description`**: Guia llegible per humans que ajuda a Codex a entendre quan desplegar aquest agent.
* **`developer_instructions`**: El conjunt d'instruccions bàsiques que dicten el comportament i la lògica operativa de l'agent.
També es poden incloure camps opcionals com `nickname_candidates`, `model`, `model_reasoning_effort`, `sandbox_mode`, `mcp_servers` i `skills.config`. Si s'ometen, aquesta configuració s'heretarà de la sessió pare, simplificant la configuració quan els valors predeterminats són acceptables. Per a les millors pràctiques en enginyeria de prompts, que influeix directament en les instruccions de l'agent, consulteu recursos com la [Guia de prompts de Codex](/ca/codex-prompting-guide).
El camp `name` és l'identificador definitiu per a un agent personalitzat. Tot i que fer coincidir el nom del fitxer amb el nom de l'agent és una convenció habitual i recomanada, el camp `name` dins del fitxer TOML és la font de veritat definitiva. El camp `nickname_candidates` és una addició útil per a l'experiència de l'usuari, ja que permet a Codex assignar noms de visualització més llegibles als agents generats, la qual cosa és particularment útil en escenaris complexos multi-agent.
## Configuració global i configuració avançada de subagents
Més enllà de les definicions d'agents personalitzats individuals, Codex ofereix configuracions globals per gestionar el comportament general dels fluxos de treball dels subagents. Aquesta configuració es troba normalment a la secció `[agents]` del vostre fitxer de configuració principal, oferint un control centralitzat sobre l'assignació de recursos i els paràmetres operacionals.
Aquí teniu un desglossament de les configuracions globals clau dels subagents:
| Camp | Tipus | Requerit | Propòsit |
| :--------------------------- | :----- | :------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `agents.max_threads` | nombre | No | Limita el nombre de fils d'agent oberts concurrents. El valor per defecte és `6` si no s'estableix. |
| `agents.max_depth` | nombre | No | Limita la profunditat d'anidament dels agents generats (la sessió arrel comença a 0). El valor per defecte és `1`. Evita la delegació recursiva més enllà dels fills immediats per gestionar l'ús de tokens i la latència. |
| `agents.job_max_runtime_seconds` | nombre | No | Estableix el temps d'espera predeterminat per a cada treballador per als treballs de `spawn_agents_on_csv`. Si no s'estableix, el valor per defecte és `1800` segons (30 minuts). |
La configuració `agents.max_threads`, amb un valor predeterminat de `6`, proporciona una salvaguarda contra el consum excessiu de recursos limitant el nombre de subagents que poden operar simultàniament. La configuració `agents.max_depth`, amb el seu valor predeterminat d'`1`, és particularment important. Si bé un anidament més profund podria semblar atractiu per a una delegació complexa, augmentar aquest valor pot provocar augments significatius en l'ús de tokens, la latència i el consum de recursos locals a causa de la repetida expansió. Generalment, es recomana mantenir el valor predeterminat, tret que un patró de delegació recursiva específic sigui absolutament necessari i gestionat amb cura.
Els fitxers d'agent personalitzats també poden incloure altres claus `config.toml` compatibles, ampliant la seva configurabilitat més enllà dels camps obligatoris. Aquest enfocament de configuració modular i per capes garanteix que els desenvolupadors tinguin un control precís sobre els seus agents d'IA, permetent-los optimitzar el rendiment, el cost i la seguretat adaptats a les seves necessitats de desenvolupament específiques. En entendre i aprofitar aquestes potents capacitats de subagent, els desenvolupadors poden ampliar els límits de la codificació assistida per IA i millorar significativament els seus fluxos de treball de desenvolupament.
Font original
https://developers.openai.com/codex/subagents/Preguntes freqüents
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.
Manteniu-vos al dia
Rebeu les últimes notícies d'IA al correu.