{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"reddit-1szxq7i","slug":"has-cursor-always-used-composer-2-for-subagents","name":"Has Cursor always used Composer 2 for subagents?","type":"agent","url":"https://i.redd.it/m65icxoh8cyg1.png","page_url":"https://unfragile.ai/has-cursor-always-used-composer-2-for-subagents","categories":["code-editors","app-builders"],"tags":["cursor"],"pricing":{"model":"unknown","free":false,"starting_price":null},"status":"pending_review","verified":false},"capabilities":[{"id":"reddit-1szxq7i__cap_0","uri":"capability://planning.reasoning.multi.agent.code.generation.with.composer.based.subagent.delegation","name":"multi-agent code generation with composer-based subagent delegation","description":"Cursor's subagent system delegates complex coding tasks to specialized Composer 2 instances that operate as independent agents within a parent task context. Each subagent maintains its own conversation state, receives task-specific prompts, and returns structured code artifacts back to the parent agent for integration. The architecture uses a hierarchical agent pattern where the main Cursor agent orchestrates subagent spawning, context passing, and result aggregation without requiring manual prompt engineering for each delegation.","intents":["break down large refactoring tasks into parallel subagent work streams","generate multiple implementation approaches simultaneously and compare results","isolate complex domain-specific code generation (e.g., database schema, API handlers) to specialized subagents","maintain clean separation of concerns when generating interdependent code modules"],"best_for":["teams building large codebases where monolithic code generation becomes unwieldy","developers working on multi-module projects requiring coordinated generation across services","builders prototyping complex systems where parallel exploration of design alternatives is valuable"],"limitations":["subagent coordination overhead adds latency proportional to number of parallel agents spawned","context window constraints may limit the complexity of tasks delegable to individual subagents","no explicit mechanism documented for handling conflicting outputs from competing subagents","subagent state is ephemeral — no built-in persistence across sessions for partial work"],"requires":["Cursor IDE with Composer 2 support enabled","sufficient API quota for multiple concurrent LLM requests (one per subagent)","project structure compatible with modular code generation patterns"],"input_types":["natural language task descriptions","existing codebase context (file references, imports)","structured task specifications with success criteria"],"output_types":["generated code artifacts (functions, modules, classes)","structured metadata about generated code (dependencies, interfaces)","integration instructions for merging subagent outputs"],"categories":["planning-reasoning","code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"reddit-1szxq7i__cap_1","uri":"capability://planning.reasoning.hierarchical.task.decomposition.with.context.propagation","name":"hierarchical task decomposition with context propagation","description":"When a user requests a complex coding task, Cursor's agent layer analyzes the request and automatically decomposes it into subtasks, each assigned to a Composer 2 subagent with relevant context extracted from the codebase. Context propagation includes file dependencies, import graphs, type definitions, and architectural patterns inferred from existing code. The parent agent maintains a task dependency graph to sequence subagent execution and merge results in topological order.","intents":["automatically break down 'refactor this entire module' into file-level or function-level subtasks","ensure subagents have access to transitive dependencies without manual specification","coordinate code generation across multiple files that must maintain type safety and import consistency","generate code that respects existing architectural patterns without explicit instruction"],"best_for":["developers working on unfamiliar codebases who need automatic dependency discovery","teams with large monorepos where manual task decomposition is error-prone","rapid prototyping scenarios where minimizing context-setup overhead is critical"],"limitations":["decomposition heuristics may over-fragment simple tasks, creating unnecessary subagent overhead","context extraction relies on static analysis — dynamic dependencies or runtime-determined imports may be missed","no explicit user control over decomposition strategy (e.g., cannot force file-level vs function-level granularity)","circular dependencies in task graph may cause deadlock or require manual intervention"],"requires":["Cursor with codebase indexing enabled","project with parseable dependency metadata (package.json, go.mod, requirements.txt, etc.)","supported language with AST parsing (TypeScript, Python, Go, Rust, etc.)"],"input_types":["natural language task request","optional file/directory scope constraints","existing codebase (indexed)"],"output_types":["task decomposition plan (DAG of subtasks)","context bundles per subagent (relevant files, imports, type definitions)","merged code artifacts with dependency resolution"],"categories":["planning-reasoning","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"reddit-1szxq7i__cap_2","uri":"capability://code.generation.editing.composer.native.code.artifact.generation.and.merging","name":"composer-native code artifact generation and merging","description":"Subagents generate code using Cursor's Composer 2 interface, which produces structured code artifacts with metadata (file path, language, dependencies, change type). The parent agent collects these artifacts and applies a merge strategy that handles conflicts (overlapping edits, import collisions, type mismatches) by consulting the codebase index and re-running generation if necessary. Merging preserves formatting, respects existing code style, and maintains referential integrity across generated modules.","intents":["generate code across multiple files and automatically merge without manual conflict resolution","ensure generated code follows project style conventions and formatting rules","detect and resolve import conflicts when multiple subagents reference the same module","validate generated code against existing type definitions before committing changes"],"best_for":["teams with strict code style requirements and automated linting/formatting pipelines","projects where import management is complex (monorepos, circular dependencies)","developers who want generated code to be immediately mergeable without review friction"],"limitations":["merge strategy is deterministic but not always optimal — may choose conservative resolution over semantically correct one","no built-in support for three-way merges if user has made local edits during subagent execution","formatting preservation relies on language-specific parsers — may fail for non-standard syntax or DSLs","type validation is best-effort and may miss runtime type errors in dynamically-typed languages"],"requires":["Cursor Composer 2 with artifact generation enabled","project with supported language (TypeScript, Python, Go, Rust, Java, etc.)","optional: .editorconfig or language-specific formatter config for style preservation"],"input_types":["code artifacts from subagents (structured with metadata)","existing codebase files (for conflict detection)","type definitions and import maps"],"output_types":["merged code files ready for commit","conflict report with resolution strategy applied","validation results (linting, type checking)"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"reddit-1szxq7i__cap_3","uri":"capability://memory.knowledge.codebase.aware.context.injection.for.subagents","name":"codebase-aware context injection for subagents","description":"Before spawning a subagent, Cursor analyzes the task and injects relevant codebase context (file snippets, type signatures, architectural patterns, existing implementations of similar features) into the subagent's system prompt. This context is extracted via static analysis of imports, symbol tables, and semantic search over the codebase index. The injection is selective — only context relevant to the task is included to avoid exceeding token limits while maintaining semantic coherence.","intents":["ensure subagents generate code consistent with existing patterns without explicit instruction","reduce token usage by injecting only relevant context rather than entire files","enable subagents to reference existing utilities and avoid reimplementing common functions","maintain type safety by providing type definitions and interface contracts upfront"],"best_for":["large codebases where full-file context is prohibitively expensive","projects with strong architectural patterns that should be replicated in generated code","teams using domain-specific abstractions that subagents must understand"],"limitations":["context selection heuristics may miss non-obvious dependencies (e.g., side effects, global state)","injected context can become stale if codebase changes during subagent execution","no mechanism to explicitly exclude context (e.g., deprecated code that should not be replicated)","semantic search may return false positives, polluting the subagent's context with irrelevant code"],"requires":["Cursor with codebase indexing and semantic search enabled","project with sufficient code examples to establish patterns","supported language with reliable symbol extraction"],"input_types":["task description","codebase index (symbols, imports, type definitions)","optional: explicit context hints from user"],"output_types":["augmented system prompt with injected context","context metadata (source files, relevance scores)","token budget estimate for the augmented prompt"],"categories":["memory-knowledge","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"reddit-1szxq7i__cap_4","uri":"capability://automation.workflow.subagent.execution.orchestration.with.dependency.sequencing","name":"subagent execution orchestration with dependency sequencing","description":"Cursor maintains a task dependency graph and schedules subagent execution in topological order, ensuring that subagents with dependencies on other subagents' outputs wait for those outputs before executing. The orchestrator handles resource constraints (API rate limits, concurrent request limits) by queuing subagents and executing them in batches. Progress is tracked and reported back to the user, with the ability to cancel or retry failed subagents.","intents":["execute multiple subagents in parallel when tasks are independent, sequentially when dependent","handle API rate limits gracefully without blocking the entire task","provide real-time feedback on subagent progress and completion status","retry failed subagents with adjusted context or prompts"],"best_for":["large refactoring tasks with many independent subtasks that benefit from parallelization","teams with limited API quotas who need intelligent batching to avoid rate limits","developers who want visibility into multi-agent execution progress"],"limitations":["dependency graph construction relies on static analysis — may miss runtime dependencies","no explicit user control over parallelization degree or batching strategy","retry logic is heuristic-based and may not recover from systematic failures (e.g., hallucinated imports)","progress reporting adds overhead and may slow down execution for very large task graphs"],"requires":["Cursor with subagent support enabled","sufficient API quota for concurrent requests (depends on parallelization degree)","task with clear dependency structure (acyclic DAG)"],"input_types":["task decomposition plan (DAG of subtasks)","resource constraints (rate limits, concurrency limits)","optional: user preferences for parallelization strategy"],"output_types":["execution schedule (topological order with batching)","progress updates (per-subagent status)","final merged output from all subagents"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":28,"verified":false,"data_access_risk":"low","permissions":["Cursor IDE with Composer 2 support enabled","sufficient API quota for multiple concurrent LLM requests (one per subagent)","project structure compatible with modular code generation patterns","Cursor with codebase indexing enabled","project with parseable dependency metadata (package.json, go.mod, requirements.txt, etc.)","supported language with AST parsing (TypeScript, Python, Go, Rust, etc.)","Cursor Composer 2 with artifact generation enabled","project with supported language (TypeScript, Python, Go, Rust, Java, etc.)","optional: .editorconfig or language-specific formatter config for style preservation","Cursor with codebase indexing and semantic search enabled"],"failure_modes":["subagent coordination overhead adds latency proportional to number of parallel agents spawned","context window constraints may limit the complexity of tasks delegable to individual subagents","no explicit mechanism documented for handling conflicting outputs from competing subagents","subagent state is ephemeral — no built-in persistence across sessions for partial work","decomposition heuristics may over-fragment simple tasks, creating unnecessary subagent overhead","context extraction relies on static analysis — dynamic dependencies or runtime-determined imports may be missed","no explicit user control over decomposition strategy (e.g., cannot force file-level vs function-level granularity)","circular dependencies in task graph may cause deadlock or require manual intervention","merge strategy is deterministic but not always optimal — may choose conservative resolution over semantically correct one","no built-in support for three-way merges if user has made local edits during subagent execution","builder identity is not verified yet","artifact is still pending review"],"rank_breakdown":{"adoption":0.4,"quality":0.1,"ecosystem":0.28,"match_graph":0.25,"freshness":0.5,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"pending_review","updated_at":"2026-05-24T12:16:25.061Z","last_scraped_at":"2026-05-04T07:51:07.891Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=has-cursor-always-used-composer-2-for-subagents","compare_url":"https://unfragile.ai/compare?artifact=has-cursor-always-used-composer-2-for-subagents"}},"signature":"uafVPSNHuuIXfYEJSt6mcaMOFr96uvn7LLb3V/WD9yLWHrBL8ISvH8Y2ZGG7RKhBA9UA8tcj+DN8gwuY3IkbBg==","signedAt":"2026-06-19T19:21:27.567Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/has-cursor-always-used-composer-2-for-subagents","artifact":"https://unfragile.ai/has-cursor-always-used-composer-2-for-subagents","verify":"https://unfragile.ai/api/v1/verify?slug=has-cursor-always-used-composer-2-for-subagents","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}