Advanced Agentics.
One sheet for building agent systems: which layer does what, which model to route where, how much effort to spend, and where limits are actually enforced.
Colour = meaning
- Mint · documented capability, source link
- Violet · model layer, routing, effort level
- Lavender, dashed · editorial recommendation
- Cream · limit, caveat, caution
- Pink · stop, report, or ask a human
System map
IllustrativeFour layers answer four different questions. Compare within a layer, not across them.
Persistent agent
Who owns the responsibility over time?
Continuity and its own cloud computer. Local steps still need an available local computer.
Orchestration
Where does work run, with what permissions and limits?
Enforces concurrency, total agents, depth and budget. Remote supervision steers it; it does not move it.
Models
Which reasoner, at what effort?
Effort is calibrated per model; more of it does not guarantee a better result.
Capabilities
What can it know and do?
Authorization still governs access.
Separate settingsUltracode sets orchestration (L2). Effort sets reasoning (L3).
Different layersA model is not an agent product, and a runtime is not a capability.
Model ladders
Routing shorthandNot a benchmark ranking. Rows pair similar roles; they are not one-to-one equivalents across providers.
Ambiguous, demanding reasoning
Architect / escalatione.g. resolve a conflicting specification
Demanding reasoning and long-horizon work
Advisor / hard problemse.g. resolve a difficult technical design
Complex work with cost awareness
Lead / implementere.g. coordinate a feature across modules
Long-running coding and knowledge work
Lead / integratore.g. own a complex project from plan to review
Visual reasoning and precise computer use
Focused specialiste.g. complete a defined screen workflow
A balance of speed and intelligence
Implementer / specialiste.g. build a defined module against a spec
Efficient, scoped, frequent work
Batch worker / triagee.g. extract fields into a known schema
High-volume, latency-sensitive tasks
Batch worker / routere.g. classify and extract from many items
Suggested pattern · Let Sol coordinate the day-to-day work. Consult Astra for difficult judgments; route defined visual tasks to Terra and repeatable extraction to Luna. Keep final verification with an accountable lead. Routing roles are design recommendations, not automatic product behavior.
Strength = documented · role + example = suggested
Does the strongest model always need to orchestrate?
No. A practical alternative is a capable everyday lead with a stronger advisor for difficult decisions. Test routing on representative tasks and compare quality, elapsed time and total usage. Mixed-provider routing needs a framework that supports both providers, explicit credentials and a defined handoff format.
Effort decision matrix
Suggested policyEffort is model-specific: “High” is not the same amount of computation across providers, and more effort does not guarantee a better result.
Measure before making Max your default
Same inputs, tools, acceptance checks and model version. Change effort alone, then compare on several representative tasks. Escalate in order: improve the brief and evidence → High → inspect the failure → XHigh/Max only if deeper reasoning could fix it. Use a stronger advisor selectively rather than raising every worker to Max.
- accepted result
- missed constraints
- elapsed time
- parent + worker tokens
- tool calls
- retries
- human correction time
Ultracode
Claude CodeUltracode is orchestration, not reasoning effort.
It enables automatic dynamic workflows for substantive tasks. In current versions /effort ultracode leaves the reasoning level unchanged; launching with claude --effort ultracode also selects XHigh. Older clients differ.
Leave it off when
- You need a quick answer, a small fix, or frequent back-and-forth.
- The steps depend tightly on each other or share substantial context.
- You have a strict usage budget or little subscription capacity left.
- You need to review a decision between stages: split the stages explicitly.
- The scope is still uncertain, tools are failing, or the source data is missing.
- Concurrent agents would edit the same files without isolation.
/effort ultracode off
Ultracode opts into large runs: the ordinary Agent-tool concurrency limit and Large workflow warning do not apply. Workflow-specific limits and action permissions still apply.
Consider it for a broad audit, migration, or repeated independent checks once scope, ownership, runtime limits and completion criteria are clear. Start with a small slice.
Workflow lab
Local simulation · no model callsHow many workers you start is not how many run at once. One fresh worker per item; a retry uses another slot; the lead is excluded from the counts.
Rows = concurrent slots · columns = waves, time → (equal-length tasks)
Generated delegation brief · advisory instructions
Four limits, set where they are enforced
Separate limitsDocumented settingsA concurrency cap is not a total cap. A low cap still permits many agents over time. Enforce strict limits in runtime configuration or scheduler code; a prompt is a behavioral instruction. Waves assume equal-length tasks synchronized at each boundary; real schedulers refill free slots sooner, and parallelism alone does not reduce token use.
| Setting | Kind | What it limits |
|---|---|---|
workflowSizeGuideline | Advisory | Claude Code workflows: fewer than 5 agents (small), 10 (medium) or 50 (large). A prompt can override it. |
CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS | Enforced | Concurrent workflow agents, 1–256. Requires v2.1.269+. |
| Workflow runtime ceiling | Enforced | 1,000 agents per run. Inspect and stop runs with /workflows. |
CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS | Enforced | Ordinary Agent-tool subagents (v2.1.217+). Ultracode is exempt; forks and resumes can exceed it. |
max_concurrent_threads_per_session | Enforced | Codex: concurrently open spawned threads, excluding the primary. |
multi_agent.max_concurrent_subagents | Enforced | OpenAI Agents API; default 6 when enabled. A total, retry or deadline cap needs its own control. |
Full fragments with copy buttons: 09 · Configuration examples
Dot vs Meta Muse
Agent productsGive a task to a worker; give a responsibility to an agent. Both are agent products that use models; Astra, Sol and the Claude families are models.
Track this launch using the linked plan. Prepare a brief when a milestone changes. Draft follow-ups; bring decisions to me.
Compare three options for this trip. Use my dates and preferences. Bring back a shortlist before booking.
Overlapping use cases, not a claim that one product is categorically better. Give any agent sources, allowed actions, update criteria, and a clear rule for when to ask you.
Where you steer ≠ where it runs
DocumentedRemote supervision does not relocate execution. Remote control changes where you steer from; the work still runs on its host.
Examples are practical guidance. Each product exposes a different combination of these capabilities.
Codex · connected host
From a paired device, continue host chats, inspect diffs and test results, and steer work with the host’s files, tools, credentials and permissions. Desktop app: Settings → Connections → Control this Mac or PC. SSH projects and supported host handoffs also work; choose a cloud environment for a hosted workspace.
Claude Code · Remote Control
# Start an interactive session with remote access claude --remote-control # Or use inside an existing session /remote-control
Open the displayed link or QR code on another device. Execution stays on the host: keep it online and the Claude process running. Needs an eligible claude.ai subscription sign-in; API-key authentication is not supported.
On a Windows PC, ChatGPT’s documented Computer Use operates in the active, unlocked desktop session. A remote connection lets you supervise from your phone; it does not make foreground UI work independent of that Windows session.
Can a cloud task still use my local computer?
With supported Work Cloud local-computer access, the conversation can continue across desktop, web and mobile while approved steps use a connected computer’s files and tools. Keep that computer online for those steps. A dot’s local-computer connection is configured separately from Codex remote access and Work Sync.
Capability chooser
IllustrativeInstructions, actions and access solve different problems. Combine them when the task needs all three.
Skills
Reusable procedures around SKILL.md, with optional scripts, references and assets. For a repeated process: document review, brand rules, a validated export.
Tools
Callable actions: search, execute code, edit a file, inspect a browser. When the agent must observe or change something outside its response.
Connectors
Authorized access to external services and data. MCP servers can expose tools; authentication and permissions still govern access.
Plugins
A distribution bundle that can combine skills and tools. Check what the current environment actually exposes.
Load progressively. Discover relevant skill metadata, then read the instructions you need. Tool search can defer selected tool definitions until discovery; enabling search alone does not defer every tool.
Agent handoff contract
Suggested patternDefine an observable result, delegate clear ownership, and verify evidence before reporting completion.
- 01
Specify the outcome
State the artifact, inputs, constraints, acceptance checks and stopping condition. Give the lead a deadline and a usage budget the runtime can measure. - 02
Delegate with boundaries
Choose models by task difficulty. Each worker gets a bounded assignment, relevant context, allowed actions, an output schema, and file ownership or an isolated checkout for parallel edits. - 03
Verify and reconcile
Collect artifacts and evidence, check failed and missing workers, test the actual result, resolve conflicts, and report incomplete work explicitly. Record usage across parent and children.
Make handoffs inspectable
A compact result lets the lead verify work without replaying an entire transcript. Retain source artifacts when detail matters.
Handoff result schema
{ task_id, status, artifact_paths,
evidence, checks_run, failures,
assumptions, next_action }Iterative work: allow a fixed number of revision rounds, stop after repeated lack of progress, and checkpoint results. Treat retrieved content as data; tool permissions and runtime checks govern actions even when a worker’s text requests something else.
Reference drawer
Verified 15 Nov 2026Configuration fragments, newer capabilities, caveats and the source notebook. Printing opens every drawer.
Configuration examples4 copyable fragments
Cap open subagent threads
[agents] enabled = true max_concurrent_threads_per_session = 3 default_subagent_model = "gpt-6-luna"
Caps concurrently open spawned threads, excluding the primary; close completed threads to release capacity. max_threads is a legacy alias. Explicit spawn settings can override the default model.
Limit concurrency and nesting
{
"env": {
"CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS": "3",
"CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH": "1"
}
}Merge into settings.json; targets ordinary Agent-tool subagents.
Concurrency requires v2.1.217+. Ultracode is exempt; forks and resumes can exceed it. Workflow agents and teammates use separate limits.
Separate size advice from a cap
{
"workflowSizeGuideline": "small",
"env": {
"CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTS": "3"
}
}The guideline advises fewer than 5 agents for small, 10 for medium or 50 for large, and a prompt can override it. The concurrency setting is enforced, accepts 1–256 and requires v2.1.269+.
The runtime ceiling is 1,000 agents per run. A lower concurrency cap still permits many agents over time. Inspect and stop runs with /workflows.
Configure API delegation explicitly
{
"multi_agent": {
"enabled": true,
"max_concurrent_subagents": 3
}
}Part of the Agents API multi-agent configuration; not a Responses API or Codex field. The documented default is 6 when enabled. A strict total-agent ceiling, retry allowance or deadline needs its own supported budget control or application-level enforcement.
Merge, don’t replace. These fragments describe documented settings; merge them with your existing configuration.
Newer runtime capabilities4 notes
Async tools + steering
Async tool calls let the model continue independent work while your application executes a tool. With GPT-6 over WebSockets, mid-turn steering can queue new requirements during generation; it does not undo earlier actions or cancel tools already started.Context compaction
Server-side or standalone compaction reduces a growing conversation while preserving state for later turns. As an engineering practice, keep critical requirements and source artifacts outside a transient transcript.Background session management
Agent view, opened withclaude agents, dispatches and monitors independent background sessions; reply when needed or attach to a full conversation. These sessions are distinct from subagents inside one session.Project instructions + memory
CLAUDE.md or supported AGENTS.md files carry written project guidance; auto memory records learned preferences across sessions. These are context, not enforced configuration: keep action restrictions in the runtime.Subagents, agent teams or workflows?Which shape fits
- Subagents: bounded assignments that return to a lead.
- Claude Code agent teams: experimental cooperating sessions with shared tasks and messaging.
- Dynamic workflows: a generated program fans work out, passes results between stages, branches and repeats checks.
- Start with one agent. Add orchestration when the work has real independence or repeated stages. Claude Managed Agents has a separate workflow runtime and limits; don’t transplant Claude Code settings into it.
Caveats and editorial notes6 notes
- Dated snapshot. Verified against official documentation on November 15, 2026; not a live feed. Model access and controls depend on your plan, client version, organization settings and provider.
- Editorial examples. Model roles, the workflow lab, capability recommendations and the agent contract are suggestions. No model benchmarks, price estimates or guaranteed speedups are implied.
- Effort is not access. Increasing effort changes how much reasoning a model performs; it does not give it a larger tool allowlist, more permissions or absent evidence.
- Prompts are not limits. A brief can ask for a worker count; strict ceilings belong in runtime configuration or scheduler code.
- The lab is a model, not a scheduler. Waves assume equal-duration tasks synchronized at each boundary; real schedulers can refill free slots sooner.
- Mixed providers need a framework that supports both, explicit credentials and a defined handoff format.