{
  "source_file": "0930",
  "source_platform": "个人博客",
  "author": "Jason Liu",
  "title_listed": "Slash Commands vs Subagents",
  "keywords": "上下文工程,子Agent,经济性",
  "domain": "大模型算法",
  "content_type": "深度技术解析",
  "is_paid_flag": "否",
  "url": "https://jxnl.co/writing/2025/08/29/context-engineering-slash-commands-subagents/",
  "publish_date": "2025-08",
  "corpus_stage": "推理部署",
  "notes": "斜杠命令vs子Agent的经济性",
  "id": "32c6df9c310c",
  "collected_at": "2026-10-02T14:29:25",
  "title": "Slash Commands vs Subagents: How to Keep AI Tools Focused - Jason Liu",
  "body_markdown": "How Do Slash Commands and Subagents Keep AI Tools Focused?\n¶\nThe main idea:\nWhen AI tools do messy tasks, they can either stay focused or get confused by too much information.\nThis is part of the\nContext Engineering Series\nthat shows how to build better AI tools based on what I've learned from coding assistants and business systems.\nKey Terms:\nContext Engineering:\nBuilding dynamic systems to provide the right information and tools in the right format so agents can accomplish tasks reliably\nContext Pollution:\nWhen valuable reasoning context gets flooded with irrelevant but computationally cheap information (logs, error traces, diagnostic output)\nContext Rot:\nThe degradation of AI performance as input length increases, where models process context less reliably in longer conversations\nSubagents:\nSpecialized AI workers that handle messy, token-intensive tasks in isolation and return only distilled insights to the main reasoning thread\nUpdate (January 2026): In most modern IDE agents, what used to be slash commands now ships as skills. Subagents are no longer a niche feature—they are built into Codex CLI and Cursor, so the patterns below map directly to current tooling.\nThrough my\nconsulting work\n, I help companies build better AI systems. AI tools often waste huge amounts of processing power on messy information. Their main thinking gets clouded.\nMost of what they process is junk\nlike test results, error logs, and long outputs that make it hard for the AI to think clearly.\nThe choice isn't about what the AI can do. It's about what it can do given the information it has and how focused it can stay on one task. When your AI tool needs to run tests, check logs, or do heavy work, you have two options: dump all that messy stuff into the main chat (slash commands), or create a separate helper to handle it cleanly (subagents).\nI'll show you the exact difference using Claude Code as an example.\nSame ability to find problems. Same results. But one way uses 169,000 processing units with 91% junk. The other uses only 21,000 units with 76% useful information—8 times cleaner.\nBy the end of this post, you'll understand:\nWhy too much messy information hurts AI performance\n(and how to measure it)\nWhen to use slash commands vs subagents\n(how to decide for users and builders)\nHow real systems work\n(Claude Code's actual setup)\nHow to audit your own workflows\n(identify subagent candidates in your current systems)\nAny AI tool that handles messy data faces this choice. This includes tools that read logs, process data, check security, or help customers.\nGood information management is how you build AI tools that work at scale.\nWant to test this yourself?\nThe\nrapid prototyping methodology\nI've developed lets you experiment with both slash commands and subagent patterns using Claude Code as a harness. You can implement the same diagnostic capability both ways and measure the context pollution differences directly—without building production infrastructure first.\nHere's the uncomfortable truth:\nbad context is cheap but toxic.\nLoading 100,000 lines of test logs costs almost nothing computationally, but it easily pollutes valuable context. A well-crafted 3,000-token feature spec gets destroyed when you dump Python outputs and error traces on top of it.\nCoding agents like Claude Code are at the forefront of solving this problem. The patterns emerging here will make it to other domains—customer support, financial analysis, medical diagnosis—within months. Understanding these architectural choices now prepares you for what's coming.\nWhat Happens on the Slash Command Path?\n¶\nTake a simple example: you're building a feature, you touch a few files, and now you need to run tests.\nYou tell your agent:\n/run-tests\nWhich triggers a prompt with a fairly long description.\nRun the tests in verbose mode and read the outputs carefully. Then inspect any of the files that have changed that might be causing issues. If you need to explore and read files to figure out what might be going on, we are also able to use Git to identify when these issues may have arisen.\nFor each failing test:\n1. Extract the stack trace and identify the exact line causing the failure\n2. Use git blame on that line to see who last modified it and when\n3. Check git log for recent commits touching those files\n4. Look at related test files that might share similar patterns\n5. If it's an import/dependency error, check package.json or requirements.txt changes\n6. Summarize findings in a structured format: test name, root cause hypothesis, suspect commits, and recommended fix\nGreat. The AI tool puts the test results right into the same conversation. But now your clean 5,000-word plan gets flooded with 150,000 words of test logs. Your AI's memory is suddenly 95% junk. It's full of error messages, long outputs, thousands of \"expected this but got that\" failures, timestamps, and system dumps.\ngantt\n    title Token Usage\n    dateFormat X\n    axisFormat %s\n\n    section User Request\n    System Message          :done, system, 0, 5000\n    User Request            :milestone, request, 5000, 5000\n\n    section Reading\n    Read      :done, 5000, 7000\n    Read      :done, 7000, 8000\n    Read      :done, 8000, 9000\n    Read      :done, 9000, 10000\n    Edit      :done, 10000, 11000\n    Edit      :done, 11000, 12000\n    Edit      :done, 12000, 13000\n    Edit      :done, 13000, 14000\n    Edit      :done, 14000, 15000\n    Edit      :done, 15000, 16000\n\n    section Running Tests (150,000 tokens)\n    Run Tests     :milestone, run, 16000, 16000\n    Read Test Outputs     :active, outputs, 16000, 49000\n    Read Log Files  :active, logs, 49000, 149000\n    Explore Git History :active, git, 149000, 166000\n\n    section Continuing the thread (Polluted)\n    User Request          :done, 166000, 167000\n    Read Files            :done, 167000, 168000\n    Edit Files            :done, 168000, 169000\nThis diagram shows how tokens accumulate when you use slash commands. You start with clean, focused work (16,000 tokens). Then\n/run-tests\ndumps 150,000 tokens of diagnostic noise into your main thread. By the time you want to continue your original feature work, your AI is drowning in random bits of raw logs, error traces, and debug info. This is exactly the kind of mess that makes\ntraditional search systems fail\n. When useful information gets buried under junk, even the best AI struggles to stay focused. The output looks like this:\n!!! example Context pollution from test failures and logs (click to expand)\n````text\nFAILED tests/test_refund.py::test_refund_with_none_guard - AssertionError: assert None is not None\nFAILED tests/test_payment.py::test_process_payment_with_refunds - IndexError: list index out of range\nFAILED tests/test_validation.py::test_validate_order_items - AttributeError: 'NoneType' object has no attribute 'items'\n\n=================================== FAILURES ===================================\n______________________________ test_refund_with_none_guard ______________________________\n\n    def test_refund_with_none_guard(self):\n        refund = RefundService.create_partial_refund(order_id=123, line_items=None)\n>       assert refund.events is not None\nE       AssertionError: assert None is not None\nE       +  where None = RefundResult(success=False, events=None, error='NoneType object is not iterable').events\n\ntests/test_refund.py:45: AssertionError\n----------------------------- Captured stdout call -----------------------------\n2025-08-29 10:15:23,456 DEBUG [RefundService] Starting refund processing for order 123\n2025-08-29 10:15:23,457 INFO [Database] Connecting to postgres://prod-db:5432/payments\n2025-08-29 10:15:23,459 DEBUG [RefundService] Processing line_items: None\n2025-08-29 10:15:23,459 DEBUG [RefundService] Validating refund parameters...\n2025-08-29 10:15:23,460 DEBUG [RefundService] Iterating through line_items...\nTraceback (most recent call last):\n  File \"/usr/local/lib/python3.9/site-packages/sqlalchemy/engine/base.py\", line 1900, in _execute_context\n    self.dialect.do_execute(\n  File \"/usr/local/lib/python3.9/site-packages/sqlalchemy/engine/default.py\", line 736, in do_execute\n    cursor.execute(statement, parameters)\npsycopg2.errors.InvalidTextRepresentation: invalid input syntax for type uuid: \"None\"\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n  File \"/app/payments/refund.py\", line 118, in process_line_items\n    for item in line_items:\nTypeError: 'NoneType' object is not iterable\n2025-08-29 10:15:23,461 ERROR [RefundService] Refund failed due to invalid line_items\n2025-08-29 10:15:23,462 INFO [Database] Connection closed\n\n________________________ test_process_payment_with_refunds ________________________\n\n    def test_process_payment_with_refunds(self):\n        payment = Payment.objects.create(amount=100.00, status='completed')\n        refunds = payment.get_refunds()\n>       assert refunds[0].amount == 25.00\nE       IndexError: list index out of range\n\ntests/test_payment.py:78: IndexError\n----------------------------- Captured stderr call -----------------------------\ndjango.db.utils.IntegrityError: FOREIGN KEY constraint failed\n\ngit log --oneline -10 payments/refund.py\na1b2c3d Remove redundant None checks in refund processing\n854cc73 Add validation for refund amounts\nb764ad9 Fix refund event creation timing\n89f0ac7 Update refund processing to handle edge cases\n853ea43 Optimize database queries in refund flow\n...\n\ngit blame payments/refund.py | grep -A5 -B5 \"for item in line_items\"\n115:     @staticmethod\n116:     def process_line_items(line_items):\n117: a1b2c3d (dev-team 2025-08-28 14:23:15 -0700) +        # Upstream should validate line_items\n118: a1b2c3d (dev-team 2025-08-28 14:23:15 -0700) +\n119: 9a7f614  (alice    2025-08-15 09:45:32 -0700)          processed = []\n120: a1b2c3d (dev-team 2025-08-28 14:23:15 -0700) +        for item in line_items:\n...\n\ncommit a1b2c3d4e5f6789 (HEAD -> feature/refund-fix, origin/feature/refund-fix)\nAuthor: dev-team <\n[email protected]\n>\nDate:   Wed Aug 28 14:23:15 2025 -0700\n\n    Remove redundant None checks in refund processing\n\n    - Cleaned up defensive programming patterns\n    - Simplified line_items processing logic\n    - Assumes upstream validation handles None cases\n    - Part of tech debt cleanup initiative\n\n payments/refund.py     | 3 +--\n tests/test_refund.py   | 2 +-\n docs/refund_api.md     | 1 +\n 3 files changed, 3 insertions(+), 3 deletions(-)\n\ndiff --git a/payments/refund.py b/payments/refund.py\nindex 1234567..abcdefg 100644\n--- a/payments/refund.py\n+++ b/payments/refund.py\n@@ -115,8 +115,7 @@ class RefundService:\n\n     @staticmethod\n     def process_line_items(line_items):\n-        if line_items is None:\n-            return []\n+        # Upstream should validate line_items\n\n         processed = []\n         for item in line_items:\n\nstdout from application logs:\n2025-08-29 10:15:20.123 [main] INFO  o.s.b.w.e.tomcat.TomcatWebServer - Tomcat started on port(s): 8080 (http)\n2025-08-29 10:15:20.127 [main] INFO  com.company.PaymentsApplication - Started PaymentsApplication in 2.456 seconds\n2025-08-29 10:15:23.445 [http-nio-8080-exec-1] INFO  c.c.p.controller.RefundController - POST /api/refunds\n2025-08-29 10:15:23.446 [http-nio-8080-exec-1] DEBUG c.c.p.service.RefundService - Processing refund request: {\"order_id\": 123, \"line_items\": null}\n2025-08-29 10:15:23.447 [http-nio-8080-exec-1] WARN  c.c.p.service.ValidationService - Received null line_items, proceeding anyway\n2025-08-29 10:15:23.461 [http-nio-8080-exec-1] ERROR c.c.p.service.RefundService - NoneType iteration error in process_line_items\n2025-08-29 10:15:23.462 [http-nio-8080-exec-1] ERROR c.c.p.controller.RefundController - HTTP 500: Internal server error during refund processing\n```\nThis is context rot in action—the well-documented phenomenon where\nAI performance degrades as input length increases\n. Recent research by\nChroma on context rot\ndemonstrates how performance degradation occurs in large context windows. As the conversation grows, it's hard to figure out what the main goal is. The more irrelevant stuff you add, the worse the AI performs. Your first 5000 words were focused on adding a new feature to the refunds system. Now 95% of your AI's memory looks like diagnostic junk. It's like the reverse of finding a needle in a haystack. You had the needle and then buried it under a pile of hay. How could you possibly go back to working on the feature without strange behavior?\nThis problem happens in more than just coding tools. As I wrote about in\nRAG Low-Hanging Fruit\n, keeping clean information is key to system performance. This matters whether you're fixing code or answering customer questions. Maybe you clear everything and start over. But there must be some way to keep your original work. Maybe you try to compress things and hope the AI can figure out what's important.\nSlash Command Token Economics\nMain thread total:\n169,000 tokens (16k clean + 150k test noise + 3k continuing)\nContext pollution:\n91% noise\nProblem:\nTest diagnostics flood your reasoning thread with massive logs\nWhat Is the Subagent Path?\n¶\nNow instead of using a slash command, you create a Test Runner helper.\nClaude Code makes this easy. Subagents are separate AI helpers with their own instructions, tools, and memory. They're like having a team of workers. Each worker does a messy job, then comes back with just the important results.\nThis approach addresses a core challenge in multi-agent systems: maintaining context coherence while enabling specialization. The key insight is that subagents should operate in isolation on well-defined tasks, then return distilled results rather than trying to collaborate continuously. This aligns with\nCognition's insights on why multi-agent systems are problematic\nfor coding tasks—the \"telephone game\" effect between agents creates more problems than benefits.\nYour test runner subagent can:\nRun all tests in ultra-verbose mode with full stack traces\nUse\nawk\nand\ngrep\nand\npython\nto parse gigabytes of application logs, database logs, and system logs\nUse Git to check when failing files last changed, including full commit diffs\nCorrelate failures with PRs and read entire code review threads\nRead all the files at fault, their imports, and related modules to hypothesize root causes\nAnalyze performance metrics and memory dumps\nIt might use 180,000 tokens in the process. It reads huge log files, parses long error traces, and checks hundreds of code files. But what comes back to your main AI is a short, clear 5,000-word report:\nTests A, B, C are failing\nRoot cause is in refund.py, introduced by PR #123\nSuggested fix: restore the None guard\nNow your main context is still tight and focused. It's 21,000 tokens total: clean plan + distilled results.\nThe mess stayed with the sidecar. Only the useful stuff came back.\nSubagent Token Economics\nMain thread total:\n21,000 tokens (16k clean + 2k summary + 3k continuing)\nSubagent burned:\n150,000 tokens (off-thread)\nContext quality:\n76% signal\nResult:\n8x cleaner main thread, same diagnostic capability\ngantt\n    title Subagent Context Management\n    dateFormat X\n    axisFormat %s\n\n    section Main Thread (Clean)\n    System Message          :done, system, 0, 5000\n    User Request            :milestone, request, 5000, 5000\n    Initial Work            :done, work, 5000, 16000\n    Spawn Test Subagent     :milestone, spawn, 16000, 16000\n    Receive Summary         :crit, done, summary, 166000, 168000\n    User Request            :done, 168000, 169000\n    Read Files              :done, 169000, 170000\n    Edit Files              :done, 170000, 171000\n\n    section Test Subagent (150,000 tokens)\n    Run Tests               :milestone, run, 16000, 16000\n    Read Test Outputs       :active, outputs, 16000, 49000\n    Read Log Files          :active, logs, 49000, 149000\n    Explore Git History     :active, git, 149000, 166000\nI've watched a test runner subagent identify failing tests, run git bisect, and trace the regression back to the PR that introduced it. It took ~7 minutes and burned ~180,000 tokens — but the main agent only saw the conclusion.\nA friend built a performance optimization subagent. Their main agent was busy implementing a UX feature, while the subagent ran scripts, parsed logs, did data analysis, and reported: \"These three functions cause 70% of latency.\" The core stayed focused on the feature; the sidecar did the heavy lifting.\nHow Does This Work in Claude Code?\n¶\nI've been diving into how Claude Code implements this stuff, and it's pretty clever.\nSlash commands are just prompt injection.\nWhen you type\n/run-tests\n, Claude Code literally injects that long-ass prompt I showed you earlier into your main thread. Everything happens in the same context window. The test outputs, the git blame, the stack traces — all of it floods your main reasoning space.\nSubagents are separate workers.\nClaude Code has pre-configured subagents like\ntest-diagnostician\nand\ngeneral-purpose\nthat spawn with their own context windows, their own tool access, everything. They're literally like shadow clones — they go off, do the work, burn 150k tokens parsing logs, and come back with just the insights.\nCodex CLI exposes this directly in the UI, and Cursor now offers the same pattern. Here is a Codex CLI snapshot:\nThe brilliance is in what gets isolated vs what gets shared.\nRead operations can be massively parallel.\nYou can have multiple subagents reading files, running git operations, parsing logs — all simultaneously. They don't step on each other because they're just consuming information. This aligns with\nAnthropic's multi-agent research approach\n, where parallel subagents explore different aspects of complex problems simultaneously.\nWrite operations need to be single-threaded.\nHere's the thing I've learned: if you have multiple agents trying to edit the same files, you get merge conflicts and broken state. So Claude Code keeps all the actual code implementation in the main thread.\nSlash commands can orchestrate subagents.\nYou might have\n/commands\nthat trigger different kinds of subagents to coordinate complex tasks. The slash command is for the orchestrator, and the subagents are how you delegate. A\n/analyze-performance\ncommand might spawn multiple subagents: one parsing application logs, another analyzing database queries, a third reviewing recent code changes. Each burns massive token budgets in parallel, but your main thread only sees the coordinated summary.\nThis creates a really elegant pattern:\nMain agent\n: \"I need to implement authentication\"\nResearch subagent\n: Goes deep on existing auth patterns (burns 80k tokens)\nSecurity subagent\n: Analyzes requirements and best practices (burns 60k tokens)\nMain agent\n: Gets two clean summaries, then implements single-threaded\nThe research happens in parallel, the implementation happens coordinated. The noise stays in the sidecars, the signal comes to main.\nI've watched this in action. A friend had a performance optimization subagent that would run scripts, parse gigabytes of logs, and do data analysis while the main agent kept working on UX features. The subagent burned ~180k tokens and came back with: \"These three functions are causing 70% of your latency.\"\nThat's exactly the kind of insight you need, without any of the noise.\nHow Does Context Engineering Apply Beyond Code?\n¶\nThis pattern applies far beyond coding assistants. The key insight is\nread-only research models\nthat burn tokens exploring messy data while keeping your main reasoning thread clean.\nComparing data rooms:\nInstead of dumping both data rooms into your main agent, spin up an agent per data room. Each agent is aware of the final report you want to generate, explores its data room independently, then feeds clean insights back to the main orchestrator.\nFinancial due diligence:\nLet subagents parse thousands of documents—regulatory filings, transaction records, legal contracts—while your main thread focuses on the strategic analysis and decision-making.\nResearch synthesis:\nMultiple agents can explore different domains or time periods in parallel, each burning massive token budgets on deep research, while your main agent receives only the distilled findings.\nThe critical distinction: this works because these are\nread-only operations\n. As\nresearch warns\n, multi-agent systems become fragile when agents start making conflicting decisions without full context. But for pure research and data exploration,\nAnthropic's approach\nshows that parallel subagents excel—they consume information simultaneously without stepping on each other's work.\nThe pattern is universal:\nburn tokens in specialized workers, preserve focus in the main thread.\nBut recognize these systems are complicated. If you're building a product, you have to decide whether you want to manually orchestrate these workflows and educate users, or build for expert users who understand the complexity.\nWhat Comes Next?\n¶\nThis architectural choice will define how agent systems scale. Teams building production agents today are implementing these patterns now, while the tooling ecosystem catches up.\nWhy this matters now:\nIt's about ergonomics and economics. With 1M+ context windows, we have bigger ambitions for what agents can do—and they're working. But long context makes it hard for users to track what's happening and burns serious money. Bad context is cheap but toxic: loading 100k lines of logs costs almost nothing computationally, but easily pollutes valuable context. A well-crafted 3,000-token Linear spec gets destroyed when you dump Jupyter notebooks and Python logs on top of it.\nThe immediate action:\nAudit your current agent workflows. Which operations generate massive, noisy outputs? Most teams can identify subagent candidates in an afternoon and implement basic context isolation within a week.\nThe teams that recognize this early will build agents that scale. The teams that ignore it will build agents that plateau under their own noise.\nThis post is part of the\nContext Engineering Series\n. For foundational concepts, start with\nBeyond Chunks: Context Engineering Tool Response\n. Next up: exploring how enterprise teams are applying these patterns to business-critical agent systems.",
  "metadata": {
    "title": "Slash Commands vs Subagents: How to Keep AI Tools Focused - Jason Liu",
    "description": "When AI tools get flooded with messy information, they lose focus. Should you use slash commands that add everything to the main chat, or subagents that work separately? A study using Claude Code.",
    "keywords": null,
    "author": "Jason Liu",
    "og:type": "website",
    "og:title": "Slash Commands vs Subagents: How to Keep AI Tools Focused - Jason Liu",
    "og:description": "When AI tools get flooded with messy information, they lose focus. Should you use slash commands that add everything to the main chat, or subagents that work separately? A study using Claude Code.",
    "og:image": "https://jxnl.co/assets/images/social/writing/2025/08/29/context-engineering-slash-commands-subagents.png",
    "og:image:type": "image/png",
    "og:image:width": "1200",
    "og:image:height": "630",
    "og:url": "https://jxnl.co/writing/2025/08/29/context-engineering-slash-commands-subagents/"
  },
  "paywall": {
    "listed_paid": false,
    "detected": false,
    "marker": "",
    "public_only": false,
    "policy": "付费/会员内容只保留页面公开可见部分，不绕过付费墙"
  },
  "crawl": {
    "success": true,
    "status_code": 200,
    "error": ""
  },
  "code_blocks": [
    {
      "file": "attachments/32c6df9c310c/code/body-000.txt",
      "chars": 11,
      "language": "text"
    },
    {
      "file": "attachments/32c6df9c310c/code/body-001.txt",
      "chars": 781,
      "language": "text"
    },
    {
      "file": "attachments/32c6df9c310c/code/body-002.txt",
      "chars": 994,
      "language": "text"
    },
    {
      "file": "attachments/32c6df9c310c/code/body-003.txt",
      "chars": 5268,
      "language": "text"
    },
    {
      "file": "attachments/32c6df9c310c/code/body-004.txt",
      "chars": 114,
      "language": "text"
    },
    {
      "file": "attachments/32c6df9c310c/code/body-005.txt",
      "chars": 825,
      "language": "text"
    }
  ],
  "images": [
    {
      "status": "ok",
      "url": "https://jxnl.co/writing/img/subagents-codex.png",
      "bytes": 325705,
      "reused": true,
      "local_path": "attachments/32c6df9c310c/images/000.png",
      "src": "https://jxnl.co/writing/img/subagents-codex.png",
      "alt": "Codex CLI subagent picker",
      "downloaded": true
    }
  ],
  "audio": [],
  "videos": [],
  "links": [
    {
      "href": "https://github.com/jxnl/blog/edit/main/docs/writing/posts/context-engineering-slash-commands-subagents.md",
      "label": "",
      "type": "a"
    },
    {
      "href": "https://github.com/jxnl/blog/raw/main/docs/writing/posts/context-engineering-slash-commands-subagents.md",
      "label": "",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/writing/2025/08/28/context-engineering-index/",
      "label": "Context Engineering Series",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/consulting/",
      "label": "consulting work",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/writing/2025/09/04/context-engineering-rapid-agent-prototyping/",
      "label": "rapid prototyping methodology",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/writing/2023/09/17/rag-is-more-than-embeddings/",
      "label": "traditional search systems fail",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/cdn-cgi/l/email-protection",
      "label": "[email protected]",
      "type": "a"
    },
    {
      "href": "https://www.anthropic.com/research/measuring-model-capabilities",
      "label": "AI performance degrades as input length increases",
      "type": "a"
    },
    {
      "href": "https://research.trychroma.com/context-rot",
      "label": "Chroma on context rot",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/writing/2024/05/11/low-hanging-fruit-for-rag-search/",
      "label": "RAG Low-Hanging Fruit",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/writing/2025/09/11/why-cognition-does-not-use-multi-agent-systems/",
      "label": "Cognition's insights on why multi-agent systems are problematic",
      "type": "a"
    },
    {
      "href": "https://www.anthropic.com/research/many-shot-jailbreaking",
      "label": "Anthropic's multi-agent research approach",
      "type": "a"
    },
    {
      "href": "https://cognition.ai/blog/dont-build-multi-agents",
      "label": "research warns",
      "type": "a"
    },
    {
      "href": "https://www.anthropic.com/engineering/multi-agent-research-system",
      "label": "Anthropic's approach",
      "type": "a"
    },
    {
      "href": "https://jxnl.co/writing/2025/08/27/facets-context-engineering/",
      "label": "Beyond Chunks: Context Engineering Tool Response",
      "type": "a"
    }
  ],
  "repair_version": 2,
  "repaired_at": "2026-10-14T10:52:56Z",
  "source_url": "https://jxnl.co/writing/2025/08/29/context-engineering-slash-commands-subagents/",
  "papers": [],
  "actual_video_files": [],
  "body_chars": 22244,
  "expected_body_images": 1,
  "discovery_status": "ok",
  "delivery_status": "ok",
  "missing_reason": "",
  "raw_html": "attachments/32c6df9c310c/pages/source.html",
  "local_html": "attachments/32c6df9c310c/pages/article.html",
  "body_base_path": "attachments/32c6df9c310c/pages/",
  "body_markdown_path": "attachments/32c6df9c310c/pages/article.md"
}