savant-code 0.0.17 → 0.0.19

package/docs/AI Coding Agents Market Research.md

@@ -0,0 +1,516 @@
+# **Comprehensive Market Research and Sentiment Analysis: Major AI Coding Agent Harnesses**
+
+The landscape of software engineering is undergoing a foundational architectural shift, transitioning from localized,
+single-file autocomplete utilities to autonomous, multi-agent coding harnesses. These advanced systems are designed to
+orchestrate complex, repository-wide refactoring, execute arbitrary terminal commands, interact with language server
+protocols (LSPs), and interface with remote continuous integration (CI) pipelines. As engineering teams deploy these
+agents to automate high-stakes development workflows, the tools themselves are subjected to intense scrutiny regarding
+their token economics, operational security, context window fidelity, and behavioral determinism.
+An exhaustive analysis of developer sentiment, repository issue trackers, security disclosures, and architectural
+changelogs reveals a sharply competitive market dominated by four primary harnesses: Anthropic’s Claude Code, OpenAI’s
+Codex, Cursor’s Composer Mode, and the open-source OpenCode platform. This report provides a deep, developer-centric
+evaluation of these four ecosystems, detailing their dominant use cases, critical architectural limitations, and the
+most aggressively requested community features driving their respective development backlogs.
+
+## **Claude Code (Anthropic)**
+
+### **Top Developer Demands & Use Cases**
+
+Claude Code has rapidly established itself as a premier terminal-native agent, highly favored by engineering teams whose
+workflows demand deep, autonomous interactions with local file systems and command-line interfaces. A primary catalyst
+for its widespread adoption is its robust integration with the Model Context Protocol (MCP), which enables developers to
+connect the agent to external enterprise infrastructure, such as Jira, Confluence, GitHub, and internal databases,
+seamlessly1. This connectivity allows Claude Code to operate not just as a code generator, but as a holistic workflow
+automation engine capable of reading issue tickets, analyzing the relevant codebase, and generating corresponding
+patches in a single terminal session.
+Security-focused CI/CD workflows represent one of the most heavily relied-upon enterprise use cases for the Claude
+harness. Organizations are increasingly deploying Claude directly into pull request pipelines via the
+claude-code-security-review GitHub Action. This integration performs diff-aware semantic security scanning,
+automatically analyzing changed files and posting contextual review comments on pull requests2. Development teams are
+choosing this AI-driven approach over traditional Static Application Security Testing (SAST) tools because Claude's
+advanced reasoning capabilities drastically reduce false positives. Specifically, the agent can be configured to filter
+out low-impact denial-of-service warnings, rate-limiting concerns, or generic input validation noise, focusing its
+computational effort on critical cryptographic flaws, hardcoded secrets, and complex injection vulnerabilities2.
+Furthermore, developers leverage Claude Code to automate routine Git operations and generate complex terminal scripts. A
+significant architectural advantage driving this adoption is the agent's dual-mode capability. The system operates in
+"Agent Mode" for prompt-driven tasks and "Tag Mode" via @claude mentions on GitHub, effectively bridging the gap between
+local terminal operations and asynchronous cloud-based team collaboration4. Advanced power users frequently augment this
+baseline functionality by building custom slash commands (e.g., /security-review) by placing targeted Markdown
+instruction files in a local .claude/commands/ directory, tailoring the agent’s analytical behavior to strict internal
+organizational standards and compliance requirements2.
+
+### **Critical Pain Points & Limitations**
+
+Despite its formidable semantic analysis capabilities, the Claude Code ecosystem suffers from severe architectural
+friction points regarding operational security, token economics, and environment fragmentation. The most critical
+vulnerability involves sophisticated supply-chain attacks exploiting the Model Context Protocol implementation. Threat
+intelligence researchers have demonstrated that malicious npm postinstall hooks can silently rewrite the \~/.claude.json
+configuration file upon package installation. By covertly altering MCP server endpoints, attackers can redirect
+authenticated requests to localhost proxies, intercepting OAuth bearer tokens in transit. This creates a persistent
+Man-in-the-Middle (MitM) attack that grants adversaries long-lived access to the developer's connected SaaS platforms
+without requiring elevated system privileges1.
+This attack surface extends beyond network interception into persistent skill poisoning. Threat actors have published
+npm packages (such as openmatrix and skillvault) that utilize postinstall hooks to silently inject malicious Markdown
+files into the \~/.claude/commands/ directory. Because these files are flagged with always\_load: true and priority:
+critical, they force the Claude Code agent to auto-approve destructive bash commands or exfiltrate codebase context in
+all future sessions. Crucially, executing npm uninstall does not remove these injected Markdown files, leaving the agent
+permanently compromised until the developer manually audits their hidden configuration directories7. Historically, the
+platform also struggled with prompt injection vulnerabilities within its CI/CD integrations. Earlier versions of the
+GitHub Action could be manipulated by malicious pull request comments into utilizing the "Read" tool to access
+/proc/self/environ, successfully exfiltrating the ANTHROPIC\_API\_KEY and other workflow credentials to external
+repositories before Anthropic mitigated the flaw in version 2.1.1284.
+Token burn and context window drift represent another major source of friction, directly impacting the financial
+viability of deploying the agent at scale. Claude Code’s reliance on static instructional files, specifically CLAUDE.md,
+creates exponential token bloat. The harness loads the CLAUDE.md file into the context prefix for every session and
+every conversational turn, meaning that a bloated 5,000-token instruction file severely reduces the effective working
+context and incurs compounding financial costs12. Furthermore, developers have reported that Claude Code automatically
+loads cloud-synced MCP connectors (such as Google Drive or Canva) when authenticated via a claude.ai account, injecting
+roughly 2,000 tokens of tool schema per turn, with no documented CLI flag to disable them13. To combat this waste,
+community developers have had to engineer custom wrappers that utilize tree-sitter to build structural Abstract Syntax
+Tree (AST) dependency graphs, feeding the agent a token-budgeted capsule of 2,400 relevant tokens rather than forcing it
+to linearly read 18,000 tokens of raw file text14.
+Environment setup speed and IDE integration friction are exacerbated by fragmented product surfaces. Developers complain
+that Anthropic maintains completely disconnected memory silos between the local Claude Code CLI, the Claude Desktop
+application, and the claude.ai web interface15. This lack of persistent session memory means that complex architectural
+context established in the web interface is entirely invisible to the terminal agent, forcing developers to manually
+copy-paste hundreds of lines of context16. Compounding this friction is the "Cowork" virtual machine architecture
+utilized by Claude Desktop on macOS, which bakes the CLAUDE.md file into a persistent sessiondata.img disk image,
+causing severe configuration drift when the developer updates their local repository instructions18. Furthermore, the
+lack of an official Linux release for the Claude Desktop application severely bottlenecks developers attempting to build
+and test Claude Code plugins, forcing an estimated 27% of professional developers to rely on community-maintained,
+reverse-engineered Debian and Arch packages19.
+
+### **Most Wanted & Highly Requested Features**
+
+The developer community is aggressively requesting the unification of agent instructions through the tool-agnostic
+AGENTS.md standard. Currently, Claude Code exclusively reads CLAUDE.md. However, as engineering teams increasingly adopt
+multi-agent workflows utilizing OpenAI Codex and Cursor alongside Claude, maintaining separate, tool-specific
+instruction files creates critical synchronization drift20. Developers are demanding that Claude Code natively parse
+AGENTS.md either as a fallback or as a merged context, allowing a single set of repository constraints to govern all
+active agents simultaneously without requiring duplicate maintenance20.
+Persistent session memory and context synchronization rank among the most critical backlog requests. Developers require
+a mechanism—such as a claude project link command—to authenticate a local workspace with a claude.ai cloud project. This
+would enable a read-only sync that pulls long-running conversation history, design decisions, and uploaded files
+directly into the local CLI environment16. Without this feature, the agent suffers from chronic "session amnesia,"
+requiring users to repeatedly explain the codebase architecture at the start of every terminal session14.
+Finally, developers are requesting syntax support for developer-only comments within CLAUDE.md instruction files. As
+these Markdown files grow to accommodate complex build commands, Git hooks, and test parameters, engineers need a way to
+leave annotations for human collaborators that the AI agent will explicitly ignore. This feature would reduce
+unnecessary token consumption and prevent the model from hallucinating or misinterpreting internal team notes as
+executable directives22.
+
+## **OpenAI Codex**
+
+### **Top Developer Demands & Use Cases**
+
+OpenAI Codex is heavily relied upon by enterprise engineering teams for its unparalleled capacity to handle multi-agent
+orchestration and always-on background automation. Built to drive real engineering work, Codex is actively deployed for
+autonomous issue triage, continuous integration alert monitoring, and massive, repository-wide refactoring campaigns24.
+The platform's core architectural strength lies in its "Multi-Agent V2" capability, which allows a sophisticated
+coordinator agent to spawn specialized subagents in parallel across built-in cloud worktrees, enabling the system to
+tackle distinct segments of a codebase simultaneously24.
+A unique, premium hardware ecosystem is also driving Codex adoption among power users. The introduction of the Codex
+Micro keypad—a physical, mechanical desktop interface developed in partnership with Work Louder—provides developers with
+dedicated tactile controls to manage parallel AI workflows28. Priced at $230, the device features illuminated keys that
+display the real-time status of various subagents (e.g., thinking, waiting for approval, error states), a rotary encoder
+dial to adjust the agent's reasoning effort on the fly, and a physical joystick to navigate workflows28. This hardware
+integration addresses the intense cognitive load of monitoring parallel AI swarms, making Codex a premium choice for
+developers who treat AI as a fleet of asynchronous digital workers rather than a simple in-editor autocomplete tool.
+Furthermore, the performance of Codex within highly constrained, headless terminal environments remains a significant
+draw. Benchmark tracking on the Terminal Bench 2.0 leaderboard reveals that customized, non-interactive harnesses built
+on top of the Codex CLI—such as the undocumented "Simple Codex" configuration—consistently achieve top-tier resolution
+rates (approaching 75.1% to 82.2% accuracy) on complex software engineering tasks, significantly outperforming standard
+interactive agents31.
+
+### **Critical Pain Points & Limitations**
+
+The architectural friction points within Codex are severe, primarily centering around catastrophic resource exhaustion,
+undocumented context window degradation, and the loss of observability in multi-agent communications. Memory leaks and
+application crashes are rampant when operating massive subagent swarms. On macOS environments, the Codex Desktop
+application has been documented triggering system-wide application memory exhaustion, consuming upwards of 130.58
+gigabytes of RAM during "Ultra" multi-agent fan-out workloads36. This exhaustion is driven by unbounded local thread
+spawning and extreme log volume generation, with diagnostics recording over 386 distinct thread IDs and nearly 3
+gigabytes of SQLite logs generated in under 30 minutes36. Conversely, on Windows environments, the CLI frequently
+crashes with an 0xC0000017 NT status, indicating virtual memory exhaustion. Because the underlying Rust architecture
+spawns a new process for each subagent, the 32-bit address space limit is rapidly consumed, and unbounded event channels
+(tx\_event) buffer thousands of turn events until the process fatally terminates37.
+
+| Memory Exhaustion Vector | Environment | Mechanism of Failure | Observed Impact |
+| :---- | :---- | :---- | :---- |
+| **Thread Proliferation** | macOS (Apple Silicon) | Unbounded subagent spawning during "Ultra" workloads | 130.58 GB RAM consumption; global OS memory exhaustion36 |
+| **Virtual Address Space** | Windows (32-bit process) | 2GB user-mode cap exceeded by Rust process generation | 0xC0000017 crash; 126-byte allocation failure37 |
+| **Unbounded Channels** | Cross-Platform (CLI) | tx\_event channels buffering turn/tool events without limits | Gradual memory leak ending in terminal OOM crashes38 |
+
+Context window drift and aggressive, unpredictable token burn are arguably the most frequent developer complaints.
+Despite OpenAI advertising a 1.05-million token context window for the flagship GPT-5.6 Sol model, developers discovered
+that Codex artificially capped the effective raw window at 353,400 tokens, which was recently and silently reduced
+further to 258,000 tokens without public changelog documentation39. This reduction is financially punitive because
+requests exceeding the 272,000-token boundary incur a massive pricing multiplier (2x input, 1.5x output) applied to the
+*entire* request39. Because Codex auto-compacts context unpredictably, developers report their rolling five-hour usage
+budgets being drained by just two or three prompts, with the system autonomously consuming reset opportunities without
+requiring explicit user confirmation41. Furthermore, statistical metadata analysis has identified severe anomalies in
+the GPT-5.5 model, where reasoning tokens consistently short-circuit at exactly 516, 1034, or 1552 tokens. This
+artificial capping of reasoning effort directly correlates with degraded logic and incorrect final answers on
+high-stakes coding tasks43.
+Finally, the introduction of encrypted payloads in the Multi-Agent V2 architecture has created a massive observability
+and orchestration blocker. To enhance data privacy, Codex now encrypts the instructional payloads sent from a root agent
+to its spawned subagents (spawn\_agent, send\_message, followup\_task). While this prevents sensitive data from
+appearing in plaintext rollout histories, it entirely blinds the human operator. When a subagent fails a task, the
+developer cannot inspect the initial instruction, making it impossible to determine if the parent agent hallucinated the
+directive or if the subagent simply failed to execute a correct prompt44. This encryption also causes catastrophic API
+request validation failures (HTTP 400 Bad Request) when developers attempt to route subagent tasks to external provider
+models (e.g., Ollama or local LLMs) that cannot decrypt the proprietary OpenAI agent\_message schema, entirely breaking
+headless multi-agent orchestration27.
+
+### **Most Wanted & Highly Requested Features**
+
+The demand for transparent observability in multi-agent workflows dominates the Codex feature backlog. Developers are
+aggressively requesting a plaintext audit trail for Multi-Agent V2 communications. The community requires a mechanism
+that preserves the encrypted delivery pipeline for the recipient model while simultaneously writing a human-readable
+task\_message companion field to the local trace logs, allowing operators to deterministically debug inter-agent
+miscommunications without needing to rely on the AI to accurately summarize its own past actions44.
+Another highly requested architectural shift is the implementation of tiered, persistent session memory. Currently,
+Codex suffers from memory contamination where architectural conventions from one project leak into unrelated
+repositories. Developers are pushing for a configurable memory scope system divided strictly into Global (cross-project
+preferences like timezone and coding style), Project (repository-specific architecture rules stored in
+memory/project/{hash}/), and Session (ephemeral task context) tiers50. This structured decay rate would allow the AI to
+retain long-term contextual knowledge without burning massive amounts of tokens on every prompt or cross-contaminating
+subagent workflows50.
+Finally, there is a strong demand for native integration with hardened execution harnesses, specifically frameworks like
+the open-source "Ralph Harness." Developers want built-in support for generator-evaluator loops that force the agent to
+achieve verifiable, deterministic states. Rather than letting a subagent drift through an endless chat context, a
+Ralph-style harness iterates a fresh-context session per step, blocking progress until a receipt-based gate (such as
+passing a CI/CD test or multi-model review) is strictly satisfied51.
+
+## **Cursor (Composer Mode)**
+
+### **Top Developer Demands & Use Cases**
+
+Cursor's Composer Mode has achieved massive market penetration by offering the most frictionless, native IDE integration
+among all modern AI coding tools. Developers overwhelmingly choose Composer due to its seamless ability to execute
+multi-file, repository-wide refactoring without requiring the user to leave the editor environment to monitor a separate
+terminal instance56. The release of Composer 2.5, built upon the highly capable Kimi K2.5 base model and extensively
+trained on multi-step synthetic reinforcement learning tasks, introduced a premium "Fast Mode" variant56. This tier
+delivers frontier-level intelligence at exceptional speeds, allowing the agent to sustain long-horizon coding work that
+requires hundreds of internal tool calls57.
+This specific environment is heavily relied upon for rapid prototyping workflows. Developers utilize Composer 2.5 to
+translate Figma design specifications directly into functional frontend components, resolve complex linting and type
+errors across dozens of files simultaneously, and aggressively iterate on application features56. The tactile user
+experience of Composer—allowing developers to review visual diffs instantly and accept or reject AI mutations inline
+using native IDE keybindings—eliminates the severe context-switching penalty inherent to pure terminal-based agents59.
+*Note regarding ecosystem overlap:* Due to the name "Composer," workflows in this IDE frequently intersect with the PHP
+dependency manager of the same name (hosted at github.com/composer/composer). While structurally distinct, AI agents
+operating within Cursor are routinely tasked with managing composer.json manifests, resolving complex PHP version
+constraints, and updating composer.lock files to ensure reproducible builds60. Agents must carefully navigate these
+package management tasks, as parsing mangled terminal output from untrusted remote Packagist sources has historically
+exposed systems to ANSI control character injection vulnerabilities (e.g., CVE-2025-67746)63.
+
+### **Critical Pain Points & Limitations**
+
+The unprecedented speed and autonomy of Composer Mode come at a dangerous cost, with "Auto-Run" permissions leading to
+catastrophic filesystem destruction. The most critical developer blocker involves quoting and escaping failures during
+background terminal executions on Windows. In multiple highly documented incidents, Composer 2.5 attempted to clean up
+standard local directories (e.g., executing an rmdir /s /q command to clear a Gradle build folder), but due to broken
+string escaping between PowerShell and the underlying cmd.exe executable, the target path collapsed to the root
+directory64. Because the agent was operating in "Run Everything" mode, it autonomously initiated recursive, silent
+deletions from the C:\\ or D:\\ drives, bypassing the Windows Recycle Bin entirely. This failure resulted in the
+permanent destruction of operating system files, personal desktops, and active Git repositories64. This terrifying
+failure mode highlights the severe architectural danger of granting an LLM unsupervised, programmatic access to
+destructive shell utilities.
+Token economics and backend stability form the second layer of community frustration. Users experience intense friction
+regarding usage limits, frequently reporting that their accounts seamlessly jump from included monthly allowances to
+expensive on-demand billing without adequate UI warnings, draining financial budgets in a matter of days58. The cost is
+severely compounded when Composer 2.5 Fast is utilized, as it carries a significantly higher per-token price multiplier
+($3.00/M input tokens vs $0.50/M for the standard variant)57. Compounding this confusion, the "Fast" variant is not
+displayed as a separate model in the dropdown menu; users must discover a hidden edit button on hover to toggle it off,
+leading to unintentional token burn69. Furthermore, during peak usage periods, the highly-touted Fast Mode frequently
+suffers from severe backend degradation, hanging on prompts for several minutes and returning "Taking longer than
+expected" timeout errors, entirely defeating the purpose of paying for the premium speed tier68.
+
+### **Most Wanted & Highly Requested Features**
+
+To mitigate the existential risk of Auto-Run data loss, the Cursor community is desperately requesting the
+implementation of a pre-execution snapshot and hook layer. Developers want the IDE to automatically snapshot target
+directories before executing any destructive shell commands, creating a deterministic, one-command "undo" state that
+does not rely on third-party file recovery software64. Concurrently, there is an aggressive demand for a hard-coded
+safety gate that strictly denies irreversible infrastructure commands (e.g., root-level recursive deletes, rm \-rf, or
+Git force-pushes) regardless of the user's permission settings, forcing a manual human review66.
+On the orchestration front, users are highly requesting the ability to enforce granular model routing for subagents.
+Currently, complex tasks spawned in Composer automatically inherit the premium parent model. Developers want
+configuration files to restrict background "Explore" or "Plan" subagents to cheaper, standard models (e.g., standard
+Composer 2.5 rather than Fast), drastically reducing the token burn associated with deep, recursive codebase analysis58.
+Finally, developers are asking for integrated prompt analysis tools that can automatically audit past conversations and
+suggest configuration changes to reduce context bloat, streamlining the IDE's token efficiency over long-running
+projects58.
+
+## **OpenCode (by Anomaly)**
+
+### **Top Developer Demands & Use Cases**
+
+OpenCode serves a distinct demographic of power users and systems engineers who demand absolute control over their AI
+coding environment. As a fully open-source, terminal-first harness boasting over 160,000 GitHub stars, its primary
+appeal is its provider-agnostic architecture73. Developers choose OpenCode because it refuses to lock them into a single
+ecosystem; they can route tasks to Anthropic, OpenAI, local models, or utilize the native "OpenCode Zen" and Manifest
+routing engines74. These advanced routers automatically evaluate the prompt and send the request to the cheapest, most
+capable model available, drastically optimizing API costs for independent developers77.
+The platform is heavily relied upon for deep GitHub Actions integration and offline, self-hosted environments.
+Engineering teams deploy OpenCode directly into their CI/CD runners using custom workflow YAML files, allowing the agent
+to autonomously triage issues, write patches on distinct Git branches, and submit pull requests entirely in the
+background based on simple /oc fix this issue comments78. Furthermore, OpenCode’s native ability to switch between
+specialized roles—such as a read-only "Plan" agent for codebase exploration and a full-access "Build" agent for
+execution—provides developers with a structured methodology for tackling unfamiliar, legacy codebases safely79.
+Advanced engineering teams also rely on OpenCode for the mathematical rigor of its benchmarking and orchestration
+extensions. The OpenCode Bench framework provides a vital use case: evaluating AI coding agents on real-world
+repositories using a weighted, variance-penalized mathematical model that scores outputs across API signature
+compliance, logic equivalence, and test coverage80. Additionally, power users frequently augment OpenCode with the
+Intent workspace architecture, which relies on an Augment Context Engine MCP to split complex tasks into highly
+organized Coordinator, Implementor, and Verifier roles, ensuring agents work in parallel without conflicting over stale
+prompts81.
+
+### **Critical Pain Points & Limitations**
+
+OpenCode's extreme architectural flexibility introduces severe vulnerabilities, most notably regarding subagent
+permission bypassing and infinite recursion loops. The agent relies heavily on an opencode.json configuration file to
+define rigid safety gates. However, parsing bugs within the tool registry cause relative and absolute file paths to be
+interpreted inconsistently. Consequently, when a parent agent delegates work to a "Task" subagent, the subagent
+completely ignores explicit deny rules, successfully editing restricted files (such as root manifests or .opencode/
+configurations) outside the designated workspace82.
+Even more critically, the platform lacks an architectural depth limit for subagent spawning. If a developer globally
+configures the task permission to allow in their root configuration, the internal nesting guard is entirely overridden.
+Subagents will infinitely spawn subagents across thousands of unique sessions, resulting in an exponential, unstoppable
+surge of API calls that rapidly drains financial accounts and quota limits before the user can terminate the process84.
+Performance constraints and basic operational bugs severely hinder the developer experience. Despite being a Terminal
+User Interface (TUI), OpenCode is an enormously heavy TypeScript application that routinely consumes over a gigabyte of
+RAM, frequently resulting in Bun runtime segmentation faults on Windows environments85. Furthermore, basic configuration
+overrides break the UI; if a user adds a subagent to opencode.json merely to assign it a cheaper model, the system
+incorrectly reclassifies it as a primary agent, flooding the bottom-bar navigation interface and rendering it
+unusable87. Finally, users relying on enterprise OAuth subscriptions (like Claude Pro/Max) experience constant
+authentication drops. OpenCode improperly interprets HTTP 429 rate-limit or quota-exceeded responses as total
+authentication failures, discarding the OAuth refresh token and forcing the developer to perform a full manual browser
+re-login multiple times a day88. Privacy concerns also plague the default routing configurations, as users discovered
+the free tier of the Grok model (which trains on user prompts) was being silently utilized as a fallback model without
+explicit user consent86.
+
+### **Most Wanted & Highly Requested Features**
+
+The OpenCode community is aggressively pushing for dynamic, runtime permission toggling. Drawing inspiration from
+competitor interfaces, developers want to use a hotkey (e.g., Shift+Tab) to instantly cycle the active agent between
+"Normal" (ask for confirmation), "Plan" (read-only), and "Auto" (yolo execution) modes without needing to restart the
+session or swap to a completely different agent profile90.
+Additionally, there is a highly requested overhaul for custom subagent orchestration. Currently, developers who define
+bespoke, heavily-instructed subagents in Markdown files are entirely unable to invoke them. The community demands that
+OpenCode properly expose these custom agents to the internal Task tool schema and allow developers to invoke them
+directly in the chat using @name routing (e.g., @gap-scout find leads), seamlessly bridging the gap between custom
+instructional prompts and the core execution engine91. Finally, developers are requesting a hard-coded maxDepth
+configuration option to track session depth via a parentID chain, providing an absolute defense-in-depth mechanism
+against runaway subagent recursion84.
+
+## **Competitive Synthesis**
+
+| Agent Harness | Primary Environment | Core Strength | Biggest Community Complaint | Top Backlog / Community-Requested Feature |
+| :---- | :---- | :---- | :---- | :---- |
+| **Claude Code** | CLI / PR Pipelines | Diff-aware semantic security reviews and autonomous GitHub PR integration via Tag Mode. | Supply chain vulnerabilities (MitM via postinstall hooks) and disjointed cloud/local memory silos. | Native AGENTS.md parsing support and local-to-cloud session memory synchronization. |
+| **OpenAI Codex** | CLI / Native Desktop | Massively parallel Multi-Agent V2 workflows and physical hardware (Codex Micro) integration. | Extreme token burn at the 272K boundary and silent application memory exhaustion (130GB+ leaks). | Plaintext audit trails for encrypted Multi-Agent V2 instructions and tiered memory scoping. |
+| **Cursor (Composer)** | Native IDE | Frictionless UI/UX for rapid multi-file refactoring and design-to-code iteration using Kimi K2.5. | Catastrophic data loss from Auto-Run shell escaping errors (e.g., rmdir /s /q from root). | Pre-execution snapshot hooks for one-command undo and hard-stops on destructive commands. |
+| **OpenCode** | CLI / Cloud Runners | Provider-agnostic routing, open-source extensibility, and rigorous variance-penalized benchmarking. | Infinite subagent recursion loops and critical file-permission bypasses in the Task tool. | Runtime permission toggling (Shift+Tab mode cycling) and proper @name routing for custom subagents. |
+
+### **Works cited**
+
+1. MCP Token Theft in Claude Code: A Man-in-the-Middle Attack Chain \- Mitiga,
+   [https://www.mitiga.io/blog/claude-code-mcp-token-theft-mitm](https://www.mitiga.io/blog/claude-code-mcp-token-theft-mitm)
+2. anthropics/claude-code-security-review \- GitHub,
+   [https://github.com/anthropics/claude-code-security-review](https://github.com/anthropics/claude-code-security-review)
+3. claude-code-security-review/README.md at main \- GitHub,
+   [https://github.com/anthropics/claude-code-security-review/blob/main/README.md?plain=1](https://github.com/anthropics/claude-code-security-review/blob/main/README.md?plain=1)
+4. Claude Code GitHub Action Flaw Let One Malicious Issue Hijack Repositories,
+   [https://thehackernews.com/2026/06/claude-code-github-action-flaw-let-one.html](https://thehackernews.com/2026/06/claude-code-github-action-flaw-let-one.html)
+5. claude-code-action/CLAUDE.md at main · anthropics/claude-code-action \- GitHub,
+   [https://github.com/anthropics/claude-code-action/blob/main/CLAUDE.md](https://github.com/anthropics/claude-code-action/blob/main/CLAUDE.md)
+6. Claude Code has an MCP security problem — and your developers are already using it,
+   [https://www.csoonline.com/article/4181230/claude-code-has-an-mcp-security-problem-and-your-developers-are-already-using-it.html](https://www.csoonline.com/article/4181230/claude-code-has-an-mcp-security-problem-and-your-developers-are-already-using-it.html)
+7. \[AskJS\] Has anyone seen npm packages using postinstall to inject prompt injection files into AI coding assistants?
+   : r/javascript \- Reddit,
+   [https://www.reddit.com/r/javascript/comments/1sapj8c/askjs\_has\_anyone\_seen\_npm\_packages\_using/](https://www.reddit.com/r/javascript/comments/1sapj8c/askjs_has_anyone_seen_npm_packages_using/)
+8. PSA: npm package using postinstall to inject prompt injection files into Claude Code \- Reddit,
+   [https://www.reddit.com/r/node/comments/1sapgun/psa\_npm\_package\_using\_postinstall\_to\_inject/](https://www.reddit.com/r/node/comments/1sapgun/psa_npm_package_using_postinstall_to_inject/)
+9. I built an npm scanner and found 21 malicious packages in 24 hours, including 4 new attack vectors targeting AI
+   coding tools \- Reddit,
+   [https://www.reddit.com/r/node/comments/1sbf6j8/i\_built\_an\_npm\_scanner\_and\_found\_21\_malicious/](https://www.reddit.com/r/node/comments/1sbf6j8/i_built_an_npm_scanner_and_found_21_malicious/)
+10. \[AskJS\] Has anyone else noticed malicious npm packages targeting AI coding tools? My scanner found 21 in 24 hours
+    with 4 undocumented attack vectors : r/javascript \- Reddit,
+    [https://www.reddit.com/r/javascript/comments/1sbfcbd/askjs\_has\_anyone\_else\_noticed\_malicious\_npm/](https://www.reddit.com/r/javascript/comments/1sbfcbd/askjs_has_anyone_else_noticed_malicious_npm/)
+11. Securing CI/CD in an agentic world: Claude Code Github action case \- Microsoft,
+    [https://www.microsoft.com/en-us/security/blog/2026/06/05/securing-ci-cd-in-agentic-world-claude-code-github-action-case/](https://www.microsoft.com/en-us/security/blog/2026/06/05/securing-ci-cd-in-agentic-world-claude-code-github-action-case/)
+12. 10 Tips to Stop Burning Your Tokens in Claude Code | by Habib Mohammed | Medium,
+    [https://medium.com/@habib23me/10-tip-to-stop-burning-your-tokens-in-claude-code-4776d4ac8956](https://medium.com/@habib23me/10-tip-to-stop-burning-your-tokens-in-claude-code-4776d4ac8956)
+13. Allow disabling claude.ai connectors from Claude Code settings · Issue \#58453 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/58453](https://github.com/anthropics/claude-code/issues/58453)
+14. I cut Claude Code's token usage by 65% with a local dependency graph and it remembers what it learned across
+    sessions \- Reddit,
+    [https://www.reddit.com/r/ClaudeCode/comments/1rdo5ul/i\_cut\_claude\_codes\_token\_usage\_by\_65\_with\_a\_local/](https://www.reddit.com/r/ClaudeCode/comments/1rdo5ul/i_cut_claude_codes_token_usage_by_65_with_a_local/)
+15. Claude Code surfaces are invisible, undocumented, and unreliable — users waste significant effort on workarounds ·
+    Issue \#46770 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/46770](https://github.com/anthropics/claude-code/issues/46770)
+16. Connect claude.ai Projects to Claude Code (VS Code / CLI) · Issue \#64779 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/64779](https://github.com/anthropics/claude-code/issues/64779)
+17. Feature Request: Sync memory between Claude Code and claude.ai \#47299 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/47299](https://github.com/anthropics/claude-code/issues/47299)
+18. Claude Desktop to support project-level CLAUDE.md reading · Issue \#30530 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/30530](https://github.com/anthropics/claude-code/issues/30530)
+19. \[FEATURE\] Official Claude Desktop build for Linux (Ubuntu LTS / Debian) \#65697 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/65697](https://github.com/anthropics/claude-code/issues/65697)
+20. support AGENTS.md as a native context file alongside CLAUDE.md · Issue \#34235 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/34235](https://github.com/anthropics/claude-code/issues/34235)
+21. Agent does not read AGENTS.override.md · Issue \#11838 · openai/codex \- GitHub,
+    [https://github.com/openai/codex/issues/11838](https://github.com/openai/codex/issues/11838)
+22. \[FEATURE\] Add "comment" syntax to claude.md file format · Issue \#18119 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/18119](https://github.com/anthropics/claude-code/issues/18119)
+23. \[BUG\] Claude not following Claude.md / memory instructions · Issue \#668 \- GitHub,
+    [https://github.com/anthropics/claude-code/issues/668](https://github.com/anthropics/claude-code/issues/668)
+24. Codex in ChatGPT | AI Coding Agents for Software Engineering \- OpenAI,
+    [https://openai.com/codex/](https://openai.com/codex/)
+25. What Codex Is Missing: It's the Harness, Not the Model \#18940 \- GitHub,
+    [https://github.com/openai/codex/issues/18940](https://github.com/openai/codex/issues/18940)
+26. openai-codex · GitHub Topics, [https://github.com/topics/openai-codex](https://github.com/topics/openai-codex)  
+27. Multi-Agent V2 sends OpenAI-specific agent\_message items to external Responses providers · Issue \#33551 \- GitHub,
+    [https://github.com/openai/codex/issues/33551](https://github.com/openai/codex/issues/33551)
+28. Sam Altman’s OpenAI launched Codex Micro, a limited-edition desktop keypad for AI agents,
+    [https://timesofindia.indiatimes.com/technology/tech-news/sam-altmans-openai-launched-codex-micro-a-limited-edition-desktop-keypad-for-ai-agents/articleshow/132431390.cms](https://timesofindia.indiatimes.com/technology/tech-news/sam-altmans-openai-launched-codex-micro-a-limited-edition-desktop-keypad-for-ai-agents/articleshow/132431390.cms)
+29. OpenAI’s Codex Micro Keyboard launches at $230: A quiet debut for the AI coding companion,
+    [https://m.economictimes.com/magazines/panache/openais-codex-micro-keyboard-launches-at-230-a-quiet-debut-for-the-ai-coding-companion/articleshow/132447599.cms](https://m.economictimes.com/magazines/panache/openais-codex-micro-keyboard-launches-at-230-a-quiet-debut-for-the-ai-coding-companion/articleshow/132447599.cms)
+30. Tech Wrap Today: What’s AI appreciation day, Perplexity’s SPACE sandbox, OpenAI’s Codex keyboard and more,
+    [https://www.financialexpress.com/life/technology-tech-wrap-today-whats-ai-appreciation-day-perplexitys-space-sandbox-openais-codex-keyboard-and-more-4293767/](https://www.financialexpress.com/life/technology-tech-wrap-today-whats-ai-appreciation-day-perplexitys-space-sandbox-openais-codex-keyboard-and-more-4293767/)
+31. Clarity on the "Simple Codex" harness in Terminal Bench 2.0? \#12219 \- GitHub,
+    [https://github.com/openai/codex/discussions/12219](https://github.com/openai/codex/discussions/12219)
+32. OpenSage: Self-programming Agent Generation Engine \- arXiv,
+    [https://arxiv.org/html/2602.16891v2](https://arxiv.org/html/2602.16891v2)
+33. Simple Codex \- Terminal-Bench,
+    [https://www.tbench.ai/leaderboard/terminal-bench/2.0/simple\_codex/unknown/gpt-5.3-codex%40openai](https://www.tbench.ai/leaderboard/terminal-bench/2.0/simple_codex/unknown/gpt-5.3-codex%40openai)
+34. Terminal-Bench 2.0 leaderboard,
+    [https://www.tbench.ai/leaderboard/terminal-bench/2.0](https://www.tbench.ai/leaderboard/terminal-bench/2.0)
+35. Clarity on the "Simple Codex" harness in Terminal Bench 2.0? · Issue \#12199 \- GitHub,
+    [https://github.com/openai/codex/issues/12199](https://github.com/openai/codex/issues/12199)
+36. Codex Desktop reaches 130 GB memory during Ultra multi-agent swarm (24 GB Mac) \#33390 \- GitHub,
+    [https://github.com/openai/codex/issues/33390](https://github.com/openai/codex/issues/33390)
+37. (code=3221226505, signal=null). Most recent error: memory allocation of 126 bytes failed note: run with
+    \`RUST\_BACKTRACE=1\` environment variable to display a backtrace · Issue \#24216 · openai/codex \- GitHub,
+    [https://github.com/openai/codex/issues/24216](https://github.com/openai/codex/issues/24216)
+38. Memory leak when running multiple agents · Issue \#23749 · openai/codex \- GitHub,
+    [https://github.com/openai/codex/issues/23749](https://github.com/openai/codex/issues/23749)
+39. \[SEVERE REGRESSION\] GPT-5.6 Sol context cut again: 353K → 258K despite advertised 1.05M · Issue \#32806 ·
+    openai/codex \- GitHub, [https://github.com/openai/codex/issues/32806](https://github.com/openai/codex/issues/32806)
+40. GPT-5.6 context can cross the 272K higher-usage threshold · Issue \#32486 · openai/codex,
+    [https://github.com/openai/codex/issues/32486](https://github.com/openai/codex/issues/32486)
+41. Codex (gpt-5.5, Plus plan) — rate-limit cost per token jumped \~10-20x since June 16, draining the 5h budget in 2-3
+    prompts · Issue \#28879 \- GitHub,
+    [https://github.com/openai/codex/issues/28879](https://github.com/openai/codex/issues/28879)
+42. Codex automatically consumed my token reset opportunity during long-running task \#28525,
+    [https://github.com/openai/codex/issues/28525](https://github.com/openai/codex/issues/28525)
+43. GPT-5.5 Codex reasoning-token clustering at 516/1034/1552 may be leading to degraded performance on complex tasks
+    \#30364 \- GitHub, [https://github.com/openai/codex/issues/30364](https://github.com/openai/codex/issues/30364)
+44. Multi-agent V2 regression: subagent instructions are no longer observable \#32753 \- GitHub,
+    [https://github.com/openai/codex/issues/32753](https://github.com/openai/codex/issues/32753)
+45. Regression: encrypted MultiAgentV2 messages remove readable task audit trail · Issue \#28058 · openai/codex \-
+    GitHub, [https://github.com/openai/codex/issues/28058](https://github.com/openai/codex/issues/28058)
+46. 0.137.0 (ChatGPT account): multi\_agent\_v2 enabled in config.toml breaks every turn with spawn\_agent
+    encrypted-tools 400 · Issue \#27331 · openai/codex \- GitHub,
+    [https://github.com/openai/codex/issues/27331](https://github.com/openai/codex/issues/27331)
+47. MultiAgentV2 encrypted spawn\_agent schema returns 400: model not configured for encrypted tool use · Issue \#26753
+    · openai/codex \- GitHub,
+    [https://github.com/openai/codex/issues/26753](https://github.com/openai/codex/issues/26753)
+48. multi\_agent\_v2 subagent results unusable — parent turn fails with "Encrypted function output content could not be
+    decrypted or decoded" · Issue \#33267 · openai/codex \- GitHub,
+    [https://github.com/openai/codex/issues/33267](https://github.com/openai/codex/issues/33267)
+49. \[CLI\] GPT-5.5 forces MultiAgentV2 despite disable and hides documented custom-agent controls · Issue \#31097 ·
+    openai/codex \- GitHub, [https://github.com/openai/codex/issues/31097](https://github.com/openai/codex/issues/31097)
+50. Scoped memory management for Codex (global, project, hybrid, and per-thread options) \#18343 \- GitHub,
+    [https://github.com/openai/codex/issues/18343](https://github.com/openai/codex/issues/18343)
+51. Ralph Harness: a tiny guarded loop scaffold for Codex CLI \#29756 \- GitHub,
+    [https://github.com/openai/codex/discussions/29756](https://github.com/openai/codex/discussions/29756)
+52. Tool suggestion: Ralph Harness guarded loop scaffold · Issue \#1146 · ComposioHQ/awesome-claude-skills \- GitHub,
+    [https://github.com/ComposioHQ/awesome-claude-skills/issues/1146](https://github.com/ComposioHQ/awesome-claude-skills/issues/1146)
+53. ralph-loop · GitHub Topics,
+    [https://github.com/topics/ralph-loop?l=typescript\&o=desc\&s=forks](https://github.com/topics/ralph-loop?l=typescript&o=desc&s=forks)
+54. ralph.md \- gmickel/flow-next \- GitHub,
+    [https://github.com/gmickel/gmickel-claude-marketplace/blob/main/plugins/flow-next/docs/ralph.md](https://github.com/gmickel/gmickel-claude-marketplace/blob/main/plugins/flow-next/docs/ralph.md)
+55. lukas-grigis/ralphctl: A ralph harness for long-running AI coding tasks — a generator-evaluator loop that
+    orchestrates Claude Code, OpenAI Codex & GitHub Copilot across repositories,
+    [https://github.com/lukas-grigis/ralphctl](https://github.com/lukas-grigis/ralphctl)
+56. Share your Thoughts on Composer 2.5\! \- Release Discussions \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/share-your-thoughts-on-composer-2-5/160935](https://forum.cursor.com/t/share-your-thoughts-on-composer-2-5/160935)
+57. Composer 2.5 is now live\! \- Announcements \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/composer-2-5-is-now-live/160934](https://forum.cursor.com/t/composer-2-5-is-now-live/160934)
+58. Compose 2.5 fast \- Discussions \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/compose-2-5-fast/163036](https://forum.cursor.com/t/compose-2-5-fast/163036)
+59. Composer and Agent Mode \- Help \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/composer-and-agent-mode/51443](https://forum.cursor.com/t/composer-and-agent-mode/51443)
+60. Composer \- Dependency Manager for PHP · GitHub,
+    [https://github.com/composer/composer](https://github.com/composer/composer)
+61. Understanding Composer: composer.json, composer.lock, install, update, and the Rest of the Basics | by Chinmay Purav
+    | The Artisan's Journal | Jul, 2026 | Medium,
+    [https://medium.com/the-artisans-journal/understanding-composer-composer-json-composer-lock-install-update-and-the-rest-of-the-basics-a5b67d627ed5](https://medium.com/the-artisans-journal/understanding-composer-composer-json-composer-lock-install-update-and-the-rest-of-the-basics-a5b67d627ed5)
+62. composer/composer \- Packagist.org,
+    [https://packagist.org/packages/composer/composer](https://packagist.org/packages/composer/composer)
+63. CVE-2025-67746 Detail \- NVD,
+    [https://nvd.nist.gov/vuln/detail/CVE-2025-67746](https://nvd.nist.gov/vuln/detail/CVE-2025-67746)
+64. Cursor Agent Completely Wiped My C: Drive and Deleted Everything \- Bug Reports,
+    [https://forum.cursor.com/t/cursor-agent-completely-wiped-my-c-drive-and-deleted-everything/164675](https://forum.cursor.com/t/cursor-agent-completely-wiped-my-c-drive-and-deleted-everything/164675)
+65. An AI coding agent Composer 2.5 (Cursor) accidentally wiped most of my Desktop and nearly my project by running a
+    misquoted \`rmdir /s /q\` command. One quoting mistake turned a Gradle \`build\` cleanup into a recursive delete
+    from \`C:\\\`. Full incident report,
+    [https://forum.cursor.com/t/an-ai-coding-agent-composer-2-5-cursor-accidentally-wiped-most-of-my-desktop-and-nearly-my-project-by-running-a-misquoted-rmdir-s-q-command-one-quoting-mistake-turned-a-gradle-build-cleanup-into-a-recursive-delete-from-c-full-incident-report/164773](https://forum.cursor.com/t/an-ai-coding-agent-composer-2-5-cursor-accidentally-wiped-most-of-my-desktop-and-nearly-my-project-by-running-a-misquoted-rmdir-s-q-command-one-quoting-mistake-turned-a-gradle-build-cleanup-into-a-recursive-delete-from-c-full-incident-report/164773)
+66. Serious data loss after Cursor Agent mis-executed rmdir /s /q on Windows — seeking awareness and support \- Bug
+    Reports,
+    [https://forum.cursor.com/t/serious-data-loss-after-cursor-agent-mis-executed-rmdir-s-q-on-windows-seeking-awareness-and-support/164051](https://forum.cursor.com/t/serious-data-loss-after-cursor-agent-mis-executed-rmdir-s-q-on-windows-seeking-awareness-and-support/164051)
+67. Disk D wipe out \- Bug Reports \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/disk-d-wipe-out/165070](https://forum.cursor.com/t/disk-d-wipe-out/165070)
+68. Has something changed with composer 2.5? \- Bug Reports \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/has-something-changed-with-composer-2-5/163473](https://forum.cursor.com/t/has-something-changed-with-composer-2-5/163473)
+69. Only fast variant of Composer 2.5 is available \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/only-fast-variant-of-composer-2-5-is-available/160976](https://forum.cursor.com/t/only-fast-variant-of-composer-2-5-is-available/160976)
+70. Serious data loss after Cursor Agent mis-executed rmdir /s /q on Windows — seeking awareness and support \- \#10 by
+    Abderrahmane\_B \- Bug Reports,
+    [https://forum.cursor.com/t/serious-data-loss-after-cursor-agent-mis-executed-rmdir-s-q-on-windows-seeking-awareness-and-support/164051/10](https://forum.cursor.com/t/serious-data-loss-after-cursor-agent-mis-executed-rmdir-s-q-on-windows-seeking-awareness-and-support/164051/10)
+71. Serious data loss after Cursor Agent mis-executed rmdir /s /q on Windows — seeking awareness and support \- \#12 by
+    deanrie \- Bug Reports,
+    [https://forum.cursor.com/t/serious-data-loss-after-cursor-agent-mis-executed-rmdir-s-q-on-windows-seeking-awareness-and-support/164051/12](https://forum.cursor.com/t/serious-data-loss-after-cursor-agent-mis-executed-rmdir-s-q-on-windows-seeking-awareness-and-support/164051/12)
+72. Composer 2.5 availability on Pro \- Cursor \- Community Forum,
+    [https://forum.cursor.com/t/composer-2-5-availability-on-pro/163088](https://forum.cursor.com/t/composer-2-5-availability-on-pro/163088)
+73. Classic confinement for OpenCode \- Snapcraft Forum,
+    [https://forum.snapcraft.io/t/classic-confinement-for-opencode/51322](https://forum.snapcraft.io/t/classic-confinement-for-opencode/51322)
+74. OpenCode | The open source AI coding agent, [https://opencode.ai/](https://opencode.ai/)  
+75. Intro | AI coding agent built for the terminal \- OpenCode, [https://opencode.ai/docs/](https://opencode.ai/docs/)  
+76. Why is opencode so popular? : r/vibecoding \- Reddit,
+    [https://www.reddit.com/r/vibecoding/comments/1qf0u10/why\_is\_opencode\_so\_popular/](https://www.reddit.com/r/vibecoding/comments/1qf0u10/why_is_opencode_so_popular/)
+77. Manifest now supports OpenCode Go subscriptions : r/opencodeCLI \- Reddit,
+    [https://www.reddit.com/r/opencodeCLI/comments/1sof10t/manifest\_now\_supports\_opencode\_go\_subscriptions/](https://www.reddit.com/r/opencodeCLI/comments/1sof10t/manifest_now_supports_opencode_go_subscriptions/)
+78. GitHub \- OpenCode, [https://opencode.ai/docs/github/](https://opencode.ai/docs/github/)  
+79. anomalyco/opencode: The open source coding agent. \- GitHub,
+    [https://github.com/anomalyco/opencode](https://github.com/anomalyco/opencode)
+80. anomalyco/opencode-bench \- GitHub,
+    [https://github.com/anomalyco/opencode-bench](https://github.com/anomalyco/opencode-bench)
+81. OpenCode \+ Augment Code \= Intent : r/opencodeCLI \- Reddit,
+    [https://www.reddit.com/r/opencodeCLI/comments/1r1enqx/opencode\_augment\_code\_intent/](https://www.reddit.com/r/opencodeCLI/comments/1r1enqx/opencode_augment_code_intent/)
+82. \[Security Bug\] Subagent permissions not enforced \- configured restrictions ignored · Issue \#7474 ·
+    anomalyco/opencode \- GitHub,
+    [https://github.com/anomalyco/opencode/issues/7474](https://github.com/anomalyco/opencode/issues/7474)
+83. Permission rules not enforced for "edit" operation performed by Task subagents · Issue \#23519 · anomalyco/opencode
+    \- GitHub, [https://github.com/anomalyco/opencode/issues/23519](https://github.com/anomalyco/opencode/issues/23519)
+84. docs: warn about infinite subagent recursion when permission.task is configured globally · Issue \#17721 ·
+    anomalyco/opencode \- GitHub,
+    [https://github.com/anomalyco/opencode/issues/17721](https://github.com/anomalyco/opencode/issues/17721)
+85. Workflow runs · anomalyco/opencode \- GitHub,
+    [https://github.com/sst/opencode/actions/workflows/opencode.yml](https://github.com/sst/opencode/actions/workflows/opencode.yml)
+86. OpenCode was the first open source agent I used, and my main workhorse after exp... | Hacker News,
+    [https://news.ycombinator.com/item?id=47462013](https://news.ycombinator.com/item?id=47462013)
+87. \[Bug\]: Subagents listed in \`opencode.json\` are incorrectly treated as primary agents (ignoring \`mode:
+    subagent\` from agent files) · Issue \#22130 \- GitHub,
+    [https://github.com/anomalyco/opencode/issues/22130](https://github.com/anomalyco/opencode/issues/22130)
+88. Claude OAuth token requires re-authentication after every usage limit reset · Issue \#15562 · anomalyco/opencode \-
+    GitHub, [https://github.com/anomalyco/opencode/issues/15562](https://github.com/anomalyco/opencode/issues/15562)
+89. OpenCode – Open source AI coding agent \- Hacker News,
+    [https://news.ycombinator.com/item?id=47460525](https://news.ycombinator.com/item?id=47460525)
+90. \[Feature\]: Runtime Permission Mode Toggle (like Claude Code's Shift+Tab) · Issue \#7928 · anomalyco/opencode \-
+    GitHub, [https://github.com/anomalyco/opencode/issues/7928](https://github.com/anomalyco/opencode/issues/7928)
+91. Custom mode: "subagent" agents not invocable via @name or task tool · Issue \#29616 · anomalyco/opencode \- GitHub,
+    [https://github.com/anomalyco/opencode/issues/29616](https://github.com/anomalyco/opencode/issues/29616)