Studio Advanced Agentics
Studio Pardesco · Field guide · Ed. 2026.11

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.

Author
Randall Morgan
Verified
· official docs
Sources
18 primary links · section 09
Implies
No benchmarks, prices or speedups

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
01

System map

Illustrative

Four layers answer four different questions. Compare within a layer, not across them.

L1Agent product

Persistent agent

Who owns the responsibility over time?

OpenAI dotMeta Muse

Continuity and its own cloud computer. Local steps still need an available local computer.

L2Runtime

Orchestration

Where does work run, with what permissions and limits?

Claude CodeCodexAgents APIManaged Agents

Enforces concurrency, total agents, depth and budget. Remote supervision steers it; it does not move it.

L3Model

Models

Which reasoner, at what effort?

AstraSolTerraLunaFableOpusSonnetHaiku

Effort is calibrated per model; more of it does not guarantee a better result.

L4Capability

Capabilities

What can it know and do?

SkillsToolsConnectorsPlugins

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.

Route by taskCapability, context, effort and cost.
Bound the workConcurrency, total agents, retries and budget.
Load what you needRelevant instructions and authorized tools.
02

Model ladders

Routing shorthand

Not a benchmark ranking. Rows pair similar roles; they are not one-to-one equivalents across providers.

OpenAIAstra → Sol → Terra → Luna
AnthropicFable → Opus → Sonnet → Haiku
Escalate
AstraGPT-6 Astra

Ambiguous, demanding reasoning

Architect / escalation

e.g. resolve a conflicting specification

FableClaude Fable 5.2

Demanding reasoning and long-horizon work

Advisor / hard problems

e.g. resolve a difficult technical design

Lead
SolGPT-6.1 Sol

Complex work with cost awareness

Lead / implementer

e.g. coordinate a feature across modules

OpusClaude Opus 5.5

Long-running coding and knowledge work

Lead / integrator

e.g. own a complex project from plan to review

Specialize
TerraGPT-6.1 Terra

Visual reasoning and precise computer use

Focused specialist

e.g. complete a defined screen workflow

SonnetClaude Sonnet 5.5

A balance of speed and intelligence

Implementer / specialist

e.g. build a defined module against a spec

Batch
LunaGPT-6 Luna

Efficient, scoped, frequent work

Batch worker / triage

e.g. extract fields into a known schema

HaikuClaude Haiku 5.5

High-volume, latency-sensitive tasks

Batch worker / router

e.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.

03

Effort decision matrix

Suggested policy

Effort is model-specific: “High” is not the same amount of computation across providers, and more effort does not guarantee a better result.

Default / MediumFast feedback
HighDifficult, bounded work
XHigh / MaxSelective escalation
Useful for
DefaultExtraction, supplied-text edits, clear implementation, interactive drafts
HighSubtle bugs, conflicting evidence, edge cases, multistep reasoning
XHigh/MaxA stubborn reasoning problem or a demanding final analysis
Raise it when
DefaultThe result misses constraints or fails meaningful acceptance checks
HighWith good inputs and tools, reasoning remains the bottleneck
XHigh/MaxA controlled comparison shows a material quality gain
Skip the extra spend when

Claude Fable 5.2 APIHigh is the default and captures most of the gains in Anthropic’s evaluations. Above High, gains vary by task; Max is mainly for exceptional open-ended reasoning where time and token use matter less. Fable effort ↗
Claude Opus 5.5Begin at Medium. Reserve XHigh and Max for measured improvements; don’t carry effort settings over blindly from an older model. Opus effort ↗
Codex / ChatGPTMax gives one model more reasoning time; Ultra can distribute meaningful parts to subagents. Most tasks need neither; supported levels vary. Max / Ultra ↗

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
04A

Ultracode

Claude Code

Ultracode 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.

04B

Workflow lab

Local simulation · no model calls

How 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.

Failure case
12Workers started
4Waves
12/12Completed
0Incomplete

Rows = concurrent slots · columns = waves, time → (equal-length tasks)

Generated delegation brief · advisory instructions

04C

Four limits, set where they are enforced

Separate limitsDocumented settings
ConcurrencyWorkers active at one time. Lowering it queues work.
Total countAll new workers across the run, retries included.
DepthHow many layers of workers may delegate again.
BudgetTokens, spend or elapsed time for the whole run.

A 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.

Advisory size versus enforced runtime limits
SettingKindWhat it limits
workflowSizeGuidelineAdvisoryClaude Code workflows: fewer than 5 agents (small), 10 (medium) or 50 (large). A prompt can override it.
CLAUDE_CODE_WORKFLOW_MAX_CONCURRENT_AGENTSEnforcedConcurrent workflow agents, 1–256. Requires v2.1.269+.
Workflow runtime ceilingEnforced1,000 agents per run. Inspect and stop runs with /workflows.
CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTSEnforcedOrdinary Agent-tool subagents (v2.1.217+). Ultracode is exempt; forks and resumes can exceed it.
max_concurrent_threads_per_sessionEnforcedCodex: concurrently open spawned threads, excluding the primary.
multi_agent.max_concurrent_subagentsEnforcedOpenAI Agents API; default 6 when enabled. A total, retry or deadline cap needs its own control.

Full fragments with copy buttons: 09 · Configuration examples

05

Dot vs Meta Muse

Agent products

Give 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.

Aspect
DotOpenAI
MuseMeta personal agent
Responsibility
Ongoing work across projects; keeps working between conversations and decides when to check back as a responsibility evolves.
Everyday coordination and errands; continues tasks after you close the app.
Runs on
Its own cloud computer. Can delegate tasks to Work or Codex.
Its own cloud VM and browser, with connected services.
Continuity
Retains relevant context between conversations.
Remembers preferences. Reach it in the Muse app or WhatsApp.
Suggested fit
Watch a launch plan, prepare meeting briefs as information changes, follow unresolved questions, coordinate review-ready deliverables.
Compare travel options, coordinate appointments, organize an errand, turn a personal goal into steps and follow-ups.
Example brief
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.
Watch for
Cloud work can continue with your laptop off. Steps that need a connected local computer still need it online and available.
Available integrations, approvals and rollout determine the practical fit.
One-off deliverable→ Work or a coding agent
Fixed, repeatable check→ scheduled or event task
Changing responsibility→ persistent personal agent

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.

06

Where you steer ≠ where it runs

Documented

Remote supervision does not relocate execution. Remote control changes where you steer from; the work still runs on its host.

Capability
Provides
Execution requirement
Remote controle.g. review a local coding task from your phone
Send prompts, steer a session, review results and handle supported approvals from another device
The host and required session must remain reachable
Cloud executione.g. independent work while your laptop is off
A task runs in a hosted environment with its own files and tools
Local files or apps need a separate supported connection
Background worke.g. several independent investigations
Work continues while you use another conversation or interface
A local background job still depends on its host
Computer usee.g. inspect a desktop-only app
The agent observes and operates a graphical interface
Needs supported UI tools and app access
Schedule / evente.g. a brief after new review feedback
Start work at a time or on a supported app event
Requires an enabled trigger and accessible data

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.

07

Capability chooser

Illustrative

Instructions, 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.

08

Agent handoff contract

Suggested pattern

Define an observable result, delegate clear ownership, and verify evidence before reporting completion.

  1. 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.
  2. 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.
  3. 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.

09

Reference drawer

Verified 15 Nov 2026

Configuration fragments, newer capabilities, caveats and the source notebook. Printing opens every drawer.

Configuration examples4 copyable fragments
Codex · local client

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.

Claude Code · Agent tool

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.

Claude Code · dynamic workflows

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.

OpenAI · Agents API

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
OpenAI · Responses API

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.
OpenAI · Responses API

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.
Claude Code · research preview

Background session management

Agent view, opened with claude 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.
Claude Code · persistent context

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.
Source notebook18 official sources