llm/9b2efe03-4d9e-4db2-a79a-13cee83b17d6/batch-1-d57e6396-bf64-46a7-8b78-b1e857c98cc7-input.json
The following is content for you to classify. Do not respond to the comments—classify them.
<topics>
1. Hybrid Retrieval Methods
Related: Discussion of combining BM25 with vector search using Model2Vec embeddings, sqlite-vec, and Reciprocal Rank Fusion for better handling of mixed structured and natural language data in tool outputs
2. MCP Response Interception Limitations
Related: Clarification that context-mode cannot intercept MCP tool responses because there's no PostToolUse hook in Claude Code; only built-in tools and CLI wrappers benefit from compression
3. Prompt Cache Economics
Related: Debate about whether context compression breaks prompt caching, with concerns that verbose but cached context might be cheaper than compressed context that invalidates cache
4. Agentic Context Management
Related: Ideas about models managing their own context, pruning irrelevant information, backtracking failed attempts, and treating context like git branches with cherry-picking and rebasing
5. Subagent Architecture Benefits
Related: Discussion of spawning subprocesses for work-oriented calls that don't pollute parent context, returning only summarized results to main thread
6. CLI vs MCP Tradeoffs
Related: Suggestions to use CLI tools like GitHub CLI instead of MCPs for fraction of token cost, with discussion of when each approach is appropriate
7. Tool Definition Compression
Related: Reference to Cloudflare's Code Mode approach for compressing tool definitions on input side, complementing context-mode's output side compression
8. Incremental Indexing Performance
Related: Discussion of hashing content for incremental re-embedding of changed chunks only, achieving 10-second updates versus 4-minute full reindexes
9. Extraction Script Reliability
Related: Concerns that compressing git commits to 107 bytes requires LLM to write perfect extraction scripts upfront, risking information loss when scripts are wrong
10. Context Window Visibility Tools
Related: User built claude-trace CLI to parse usage logs and break down token consumption by session, tool, project, providing measurement before optimization
11. Structured Data Challenges
Related: Observations that pure BM25 underperforms on tool outputs mixing JSON, tables, config with natural language, requiring hybrid approaches
12. Quality vs Token Savings
Related: Questions about whether compressed context produces equivalent output quality, noting extended sessions only matter if reasoning quality holds
13. Hook Aggressiveness Concerns
Related: Criticism that blocking all curl/wget for 56KB snapshots is excessive when many API calls return minimal data; author acknowledged and removed
14. Dataframe Approach for Logs
Related: Alternative approach creating in-memory parquet dataframes with token-optimized summary views for database and log system responses
15. Backtracking and Pruning
Related: Ideas for automatically detecting retry patterns and pruning failed attempts once correct solution is found, treating context as editable rather than append-only
16. Cross-Platform Compatibility
Related: Questions about support for Codex, Zed Agent, and other platforms beyond Claude Code, noting implementation should be agent-independent
17. Skills vs MCP Debate
Related: Some users suggest using skills and CLI instead of injecting MCP into context, questioning whether skills running in subagents save context
18. Tool Count Management
Related: Discussion of whether 80+ tools in context is the real problem, suggesting sub-agents for areas of focus rather than compressing everything
19. Early Internet Parallels
Related: Observation that current coding agent optimization feels like late 1990s HTML/SQL era, with experienced engineers quickly spotting bottlenecks
0. Does not fit well in any category
</topics>
<comments_to_classify>
[
{
"id": "47198998",
"text": "Do you need 80+ tools in context? Even if reduced, why not use sub agents for areas of focus? Context is gold and the more you put into it unrelated to the problem at hand the worse your outcome is. Even if you don't hit the limit of the window. Would be like compressing data to read into a string limit rather than just chunking the data"
}
,
{
"id": "47200338",
"text": "That's a fair point and honestly the ideal approach. But in practice most people don't hand-curate their MCP server list per task. They install 5-6 servers and suddenly have 80 tools loaded by default. Context-mode doesn't solve the tool definition bloat, that's the input side problem. It handles the output side, when those tools actually run and dump data back. Even with a focused set of tools, a single Playwright snapshot or git log can burn 50k tokens. That's what gets sandboxed."
}
,
{
"id": "47198943",
"text": "AFAIK Claude Code doesn't inject all the MCP output into the context. It limits 25k tokens and uses bash pipe operators to read the full output. That's at least what I see in the latest version."
}
,
{
"id": "47200293",
"text": "That's true, Claude Code does truncate large outputs now. But 25k tokens is still a lot, especially when you're running multiple tools back to back. Three or four Playwright snapshots or a batch of GitHub issues and you've burned 100k tokens on raw data you only needed a few lines from. Context-mode typically brings that down to 1-2k per call while keeping the full output searchable if you need it later."
}
,
{
"id": "47204700",
"text": "We do a fun variant of this for louie.ai when working with database and especially log systems -- think incident response, SRE, devops, outage investigations: instead of returning DB query results to the LLM, we create dataframes (think in-memory parquet). These directly go into responses with token-optimized summary views, including hints like \"... + 1M rows\", so the LLM doesn't have to drown in logs and can instead decide to drill back into the dataframe more intelligently. Less iterative query pressure on operational systems, faster & cheaper agentic reasoning iterations, and you get a nice notebook back with the interactive data views.\n\nA curious thing about the MCP protocol is it in theory supports alternative content types like binary ones. That has made me curious about shifting much of the data side of the MCP universe from text/json to Apache Arrow, and making agentic harnesses smarter about these just as we're doing in louie."
}
,
{
"id": "47205937",
"text": "How is this different than RAG?"
}
,
{
"id": "47204429",
"text": "As a newbie user that doesn't understand much of this but has claude pro and wants to use it\n\n1. Can this help me?\n2. How?\n\nThanks for sharing and building this."
}
,
{
"id": "47205093",
"text": "I've been running https://github.com/rtk-ai/rtk for a week seems to be a good balance between culling out of context and not just killing everything. I've been running https://github.com/Opencode-DCP/opencode-dynamic-context-pru... in opencode as well. It seems more aggressive."
}
,
{
"id": "47200514",
"text": "This article's specific brand of AI writing reminded me of Kevin's Small Talk\n\nhttps://www.youtube.com/watch?v=bctjSvn-OC8"
}
,
{
"id": "47198888",
"text": "This sounds a little bit like rkt? Which trims output from other CLI applications like git, find and the most common tools used by Claude. This looks like it goes a little further which is interesting.\n\nI see some of these AI companies adopting some of these ideas sooner or later. Trim the tokens locally to save on token usage.\n\nhttps://github.com/rtk-ai/rtk"
}
,
{
"id": "47200289",
"text": "Haven't looked at rtk closely but from the description it sounds like it works at the CLI output level, trimming stdout before it reaches the model. Context-mode goes a bit further since it also indexes the full output into a searchable FTS5 database, so the model can query specific parts later instead of just losing them. It's less about trimming and more about replacing a raw dump with a summary plus on-demand retrieval."
}
,
{
"id": "47200731",
"text": "Yeah I like this approach too. I made a tool similar to Beads and after learning about RTK I updated mine to produce less token hungry output. I'm still working on it.\n\nhttps://github.com/Giancarlos/guardrails"
}
,
{
"id": "47200893",
"text": "Does context mode only work with MCPs? Or does it work with bash/git/npm commands as well?"
}
,
{
"id": "47202437",
"text": "I'm not sure it actually works with MCPs *at all*, trying to get that clarified. How can context-mode get \"into the MCP loop\"?"
}
,
{
"id": "47202628",
"text": "See my comment above, context-mode has no way to inject itself into the MCP tool-call - response loop.\n\nStill high-value, outside MCPs."
}
,
{
"id": "47200730",
"text": "I’m also trying to see which one makes more sense. Discussion about rtk started today: https://news.ycombinator.com/item?id=47189599"
}
,
{
"id": "47195377",
"text": "Excited to try this. Is this not in effect a kind of \"pre-compaction,\" deciding ahead of time what's relevant? Are there edge cases where it is unaware of, say, a utility function that it coincidentally picks up when it just dumps everything?"
}
,
{
"id": "47200350",
"text": "Yeah it's basically pre-compaction, you're right. The key difference is nothing gets thrown away. The full output sits in a searchable FTS5 index, so if the model realizes it needs some detail it missed in the summary, it can search for it. It's less \"decide what's relevant upfront\" and more \"give me the summary now, let me come back for specifics later.\""
}
,
{
"id": "47205935",
"text": "Would be interested to know if this architecture facilitates dynamic context injection from external knowledge sources without inflating the payload again."
}
,
{
"id": "47205107",
"text": "On here: https://cc-context-mode.mksg.lu/#/3/0/3\n\n> Bun auto-detected for 3–5x faster JS/TS execution\n\nThis is quite a claim, and even so, doesn't matter since the bottleneck is the LLM and not the JS interpreter. It's a nit, but little things like this just make the project look bad overall. It feels like nobody took the time to read the copy before publishing it.\n\nMore importantly, the claimed 98% context savings are noise without benchmarks of harness performance with and without \"context mode\".\n\nI'm glad someone is working on this, but I just feel like this is not a serious solution to the problem."
}
,
{
"id": "47198543",
"text": "I did this accidentally while porting Go to IRIX: https://github.com/unxmaal/mogrix/blob/main/tools/knowledge-..."
}
,
{
"id": "47200314",
"text": "Nice approach. Same core idea as context-mode but specialized for your build domain. You're using SQLite as a structured knowledge cache over YAML rule files with keyword lookup. Context-mode does something similar but domain-agnostic, using FTS5 with BM25 ranking so any tool output becomes searchable without needing predefined schemas. Cool to see the pattern emerge independently from a completely different use case."
}
,
{
"id": "47198771",
"text": "I've seen a few projects like this. Shouldn't they in theory make the llms \"smarter\" by not polluting the context? Have any benchmarks shown this effect?"
}
,
{
"id": "47200344",
"text": "That's the theory and it does hold up in practice. When context is 70% raw logs and snapshots, the model starts losing track of the actual task. We haven't run formal benchmarks on answer quality yet, mostly focused on measuring token savings. But anecdotally the biggest win is sessions lasting longer before compaction kicks in, which means the model keeps its full conversation history and makes fewer mistakes from lost context."
}
,
{
"id": "47203899",
"text": "> When context is 70% raw logs and snapshots, the model starts losing track of the actual task\n\nWhich frontier model will (re)introduce the radical idea of separating data from executable instructions?"
}
,
{
"id": "47202743",
"text": "Thanks for this. I do most of my work in subagents for better parallelization. Is it possible to have it work there? Currently the stats say subagents didn't benefit from it."
}
,
{
"id": "47200130",
"text": "If this breaks the cache it is penny wise, pound foolish; cached full queries have more information and are cheap. The article does not mention caching; does anyone know?\n\nI just enable fat MCP servers as needed, and try to use skills instead."
}
,
{
"id": "47200320",
"text": "It doesn't break the cache. The raw data never enters the conversation history, so there's nothing to invalidate. A short summary goes into context instead of the full payload, and the model can search the full data from a local FTS5 index if it needs specifics later. Cache stays intact because you're just appending smaller messages to the conversation."
}
,
{
"id": "47197578",
"text": "I am a happy user of this and have recommended my team also install it. It’s made a sizable reduction in my token use."
}
,
{
"id": "47200353",
"text": "Thanks, really appreciate hearing that! Glad it's working well for your team."
}
,
{
"id": "47202501",
"text": "HN Mod here. Is the date on the post an error? It says Feb 2025 but the project seems new. I initially went to put a date reference on the HN title but then realised it's more likely a mistake on your post."
}
,
{
"id": "47204412",
"text": "interesting...this shoudl work with codex too right ?"
}
,
{
"id": "47203792",
"text": "> With 81+ tools active,\n\nI see your problem."
}
,
{
"id": "47203941",
"text": "“you’re holding it wrong” - ok, or we could make it better"
}
,
{
"id": "47204424",
"text": "Sometimes people are actually holding it wrong though"
}
,
{
"id": "47202905",
"text": "are people still injecting mcp into their context ? lmao.\n\nUse skills and cli instead."
}
,
{
"id": "47204175",
"text": "Does the skill run in a subagent, saving context?"
}
]
</comments_to_classify>
Based on the comments above, assign each to up to 3 relevant topics.
Return ONLY a JSON array with this exact structure (no other text):
[
{
"id": "comment_id_1",
"topics": [
1,
3,
5
]
}
,
{
"id": "comment_id_2",
"topics": [
2
]
}
,
{
"id": "comment_id_3",
"topics": [
0
]
}
,
...
]
Rules:
- Each comment can have 0 to 3 topics
- Use 1-based topic indices for matches
- Use index 0 if the comment does not fit well in any category
- Only assign topics that are genuinely relevant to the comment
Remember: Output ONLY the JSON array, no other text.
37