### Model selection & granularity
- Match model capability to the agent role. Use smaller, cheaper models for high-volume routing/triage and larger, more capable models for specialist reasoning or multimodal work.
+- Prefer the latest provider-recommended model classes for specialist reasoning when available (example: OpenAI GPT-5.4 as the current high-capability class at the time of writing). Benchmark latency and cost for both router and specialist roles on representative workloads.
+- Recent community signals and vendor updates show managed agent hosting and model-native harnesses are now common; test managed offerings for latency, cost, and sandboxing trade-offs before committing to a deployment architecture (see provider docs linked in Tooling & libraries).
−- Recent community signals show open models are viable for many agent tasks. Evaluate them on your workloads before committing.
+- For routers, optimize for classification accuracy and latency; for specialists, optimize for reasoning depth and tool integration (code execution, file system access, multimodal inputs).
−- Platform-hosted models (e.g., OpenAI GPT-5.4, Codex on provider platforms) are now offered as part of managed agent hosting; benchmark their latency and cost against in-house or open alternatives when planning enterprise deployments (OpenAI: "Enterprises power agentic workflows in Cloudflare Agent Cloud" — see OpenAI signals).
−- Important: OpenAI's Agents SDK (Apr 15, 2026) introduces a model-native harness and native sandbox execution. The SDK includes SandboxAgent and SandboxRunConfig primitives and example clients (e.g., UnixLocalSandboxClient) to run agents in controlled workspaces — upgrade guidance in the OpenAI developer docs shows the package example using openai-agents>=0.14.0 and sandboxing primitives (https://openai.com/index/the-next-evolution-of-the-agents-sdk/, https://developers.openai.com/api/docs/guides/agents/sandboxes).
−- Consider model latency and token budget per hop; design the graph to minimize unnecessary round-trips (summarize between hops when appropriate).
−- For long-running or deep tasks, prefer non-blocking subagent patterns (async subagents) so supervisors can continue interacting with users while background work completes. LangChain Deep Agents documents async subagent lifecycle semantics and task-management primitives; adopt similar lifecycle semantics (start/check/update/cancel/list) when implementing background tasks (https://blog.langchain.com/deep-agents).
### Agent authorization and credentials
@@ −73 +71 @@
## Async & long-running tasks
- Adopt task lifecycle semantics: start_async_task, check_async_task, update_async_task, cancel_async_task, list_async_tasks. Persist task IDs, status, provenance, expected duration, and owner in your external store.
+- LangChain's Deep Agents work and related community implementations formalize async subagent lifecycle semantics for background work (start/check/update/cancel/list) — adopt similar lifecycle semantics when implementing supervisors and UIs (see LangChain Deep Agents: https://blog.langchain.com/deep-agents).
−- LangChain Deep Agents describes async subagents and treating background work as first-class tasks — follow those lifecycle semantics when designing supervisors and UIs (https://blog.langchain.com/deep-agents).
+- OpenAI's Agents SDK now includes native sandbox execution primitives suitable for long-running, file-based workflows where an agent must inspect or modify a controlled workspace. Use sandboxed agents to isolate untrusted execution and restrict filesystem/tool access; see the OpenAI sandboxes guide for primitives such as SandboxAgent and SandboxRunConfig (OpenAI docs: https://developers.openai.com/api/docs/guides/agents/sandboxes).
−- OpenAI Agents SDK now includes native sandbox execution which is well suited for long-running, file-based workflows where the agent must inspect or modify a controlled workspace. Use sandboxed agents to isolate untrusted execution and restrict filesystem/tool access (OpenAI: Apr 15, 2026 announcement and docs). Example primitives: SandboxAgent, SandboxRunConfig, UnixLocalSandboxClient (see OpenAI docs for exact SDK version and example code).
- Design supervisors to avoid blocking on long-running subagents: allow the supervisor to continue interacting with the user, poll or subscribe to task completion events, and provide follow-up instructions to running tasks when necessary.
- Ensure idempotency and cancellation semantics for background tasks. Provide meaningful timeouts and resource limits; surfaced task metadata should include expected duration and resource class.
@@ −101 +99 @@
### Step 3: Run the orchestration loop — secure execution
−- For agents that execute code or write files, run untrusted code in isolated sandboxes. Use timeouts and resource limits. OpenAI's Agents SDK provides sandbox primitives and examples for controlled workspaces — upgrade your SDK where applicable and follow provider guidance for sandbox configuration.
+- For agents that execute code or write files, run untrusted code in isolated sandboxes. Use timeouts and resource limits. OpenAI's Agents SDK provides sandbox primitives and examples for controlled workspaces — consult the SDK docs for configuration and runtime examples (https://developers.openai.com/api/docs/guides/agents/sandboxes).
- Signal streaming data with agent identity so consumers can attribute output to the correct agent.
### Step 4: Add guardrails and safety processes
@@ −111 +109 @@
## Tooling & libraries
+- OpenAI Agents SDK (Apr 2026): model-native harness + native sandbox execution. See the SDK docs for SandboxAgent, SandboxRunConfig, and client examples (e.g., UnixLocalSandboxClient) for file-based workflows and isolated execution (OpenAI docs: https://developers.openai.com/api/docs/guides/agents/sandboxes).