Triton Inference Server

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

This is insane.

Just installed an open source tool that wiped most of the tool-definition tokens out of my Claude Code context before any prompt. Same MCP servers. Same tools available. 8 servers, 142 tools across them. Before: the tool definitions ate 38k tokens of context every single turn. Cold start, my context bar was already orange and I hadn't typed anything. After: 4k. The Claude Code session sees three tools (`search_tools`, `invoke_tool`, `auth`) and dispatches everything else under the hood. When I ask for a thing, it ranks the catalog with BM25 in microseconds and surfaces the top 5. The part nobody's talking about: there's no LLM in the ranking loop. No embedding API to pay. No vector DB to host. It's keyword search over a flat projection of tool name + description, deterministic, offline. Apparently this was always going to be enough. It's [Ratel](https://github.com/ratel-ai/ratel). Open source. The install is `ratel mcp import` and it migrates your existing Claude Code MCP config in one command, with backups written automatically. Took me 90 seconds. Why is every "context layer" startup pitching me semantic embeddings and inference-time re-ranking when basic BM25 over tool definitions does this?

Glasses will fail

You are looking at the exact argument tech skeptics and infrastructure engineers are making right now. While the marketing for AI smart glasses promises a magical, seamless sci-fi world, the physical reality is that **AI glasses are heavily limited by the invisible infrastructure stack underneath them.** If AI glasses fail to become the next smartphone, it won't be because the hardware frames look bad; it will be because our modern networking and cloud structures aren't built to handle them yet. Here is exactly how infrastructure bottlenecks threaten to break the AI glasses dream: ### 1. The Tethering Trap & Cellular Bottlenecks To keep smart glasses lightweight and fashionable, manufacturers cannot pack them with heavy, heat-generating computer processors or massive batteries. Because of this, the glasses are mostly just "dumb" collectors of data—cameras and microphones. The heavy lifting has to happen in the cloud. This creates an immediate infrastructure dependency: * **The Upload Problem:** Standard cellular networks (even 5G) are optimized for *downloading* data (streaming video, browsing). AI glasses flip this dynamic—they require constant, high-bandwidth *uploading* of live video and audio streams so the cloud AI can process your surroundings. * **Network Congestion:** If you are in a crowded stadium, a packed subway station, or a busy downtown area, cellular bandwidth chokes. When your phone drops to one bar, your webpage loads slowly. When AI glasses lose bandwidth, they suffer **contextual blindness**—the AI simply stops responding, freezes, or lags out mid-conversation. ### 2. The Edge Compute & Latency Deficit For AI glasses to be useful, they have to operate in real time. If you look at a sign in a foreign country, you need the translation instantly, not 4 seconds later. ``` [ Glasses Capture Video ] ──(Cell Tower)──> [ Distant Data Center ] │ (Processing) [ Live Display Updates ] **The Takeaway:** The industry is fighting a classic hardware-versus-infrastructure battle. Companies like Meta and Google are successfully designing beautiful frames, but until 5G coverage expands, edge computing matures, and server architecture scales to handle millions of continuous video streams, AI glasses risk remaining a novelty gadget rather than a daily essential. > submitted by /u/Annual_Judge_7272 [link] [comments]

Opus 4.6/4.7 regression is real and getting worse — 3 weeks of documented failures on a complex project, and a competing AI caught the mistakes Claude missed [long post]

I've been running Claude Pro (Opus 4.7 / Sonnet 4.6) for about 3 weeks on a complex personal AI infrastructure project. I keep structured session logs with timestamps and Birkenbihl-style metacognitive fields after every session. This is not anecdotal — I have receipts. **The project for context** I'm building a local persistent AI memory stack called GSOC Brain: Qdrant vector DB (\~397K vectors across 11 source tags), Neo4j graph (123 nodes / 183 edges), Graphiti 0.29 entity extraction, Ollama with qwen2.5:14b + nomic-embed-text — all running natively on a Windows host. The system is supposed to give Claude cross-chat memory via a custom MCP server. On top of that, I'm operating 18+ custom skill files that define behavior rules for Claude across domains (OSINT/forensics, legal, content, infrastructure). The system prompt explicitly describes the full architecture on every session start. This is not a "chat with Claude" use case. This is sustained agentic work across multiple tools, multiple sessions, strict context requirements, and high-stakes outputs (including legal document drafts). **Bug 1: Token overconsumption since update 2.1.88 (late March 2026)** Opus 4.7 started burning daily usage limits at a completely different rate after an update around March 31. In one session I hit **94% of my daily limit within approximately 4 messages**. The boot sequence — fetching context from Notion MCP, searching past sessions, loading memory — consumed what felt like 10–20x the previous token rate. GitHub issues #42272, #50623, and #52153 document identical patterns from other users. The model appears to over-generate internally even for simple responses. End result: I had to switch to Sonnet 4.6 for most productive work because Opus 4.7 is simply unusable under the daily limit. **Bug 2: Claude Code Desktop App completely broken (reported May 14, Conv. 215474208295333)** The Desktop App hangs on **every single input**. Including typing "hello" with no files. Reproducible across: * Sonnet 4.6 and Opus 4.7 * Multiple fresh sessions * With and without u/file references * After full reinstall The VS Code extension works fine. Only the Desktop App is broken. Reported May 14. No fix, no acknowledgment. **Bug 3: Platform / context confusion — 5 documented errors in a single session, chat aborted** On April 29, I had to formally abort an Opus 4.7 session and hand off to Opus 4.6 after documenting 5 consecutive errors. The session log entry literally reads "Opus 4.7 Abbruch (5 Fehler): Zeitrechnung, Platform-Verwechslung, falsche Schlüsse": 1. Miscalculated the current time despite being told the exact time 2. Insisted the Brain stack was running on a Linux VM (BURAN) — the system prompt and memory both explicitly stated `C:\gsoc-brain` on Windows 3. Drew false inferences from backup file paths rather than the stated architecture 4. Contradicted the stated platform in the same response it had just received 5. Confused WebClaude and Desktop Claude capability boundaries These aren't edge cases. The architecture was in the system prompt, in memory, and in the injected Notion context. Opus 4.7 ignored all of it. **Bug 4: Skill files ignored in production** I maintain 18+ custom skill files loaded into the system prompt. These include explicit hard rules — e.g., "activate `keilerhirsch-knowledge` skill for ALL architecture decisions, web search is not optional." In the session that caused the Docker-to-Native migration disaster, I later wrote in my own session log: > The model proceeded to recommend outdated tools from training data rather than searching current documentation. It recommended **NSSM** (last meaningful update 2017) as a Windows service wrapper. NSSM is dead. A competing AI caught this immediately. **Bug 5: Another AI caught what Claude missed in a single pass** This is the part that stings most. When the Docker-based Brain setup kept failing, I fed the architecture docs into another AI (Manus) for a deep audit. In one pass it identified **5 critical corrections** that Claude had never caught across weeks of sessions: * NSSM is dead since \~2017 → correct replacement is WinSW or Servy * Neo4j 2025.01+ **requires Java 21** — Claude had never flagged this, the services kept failing silently * Qdrant needs Windows file-handle-limit adjustments to run reliably * Orphaned vector risk between Qdrant ↔ Neo4j without a Tentative-Write pattern in the save operation * BGE-M3 embeddings (MTEB 63.2, 8192 token context) as a better alternative to nomic-embed-text My own session log the next day reads: > Claude was answering from stale training data. The skill that explicitly says "don't do this" was being ignored. Another AI caught it in round one. **Bug 6: MCP Server 20-minute Neo4j hang — still unresolved** After the native migration, the custom `gsoc_mcp_server.py` developed a reproducible hang of exactly \~20 minutes between Qdrant connect and Neo4j connect on every startup. Log timestamps fr

Agentic Workflow Visualization and API Gateway

I am building an API gateway for agents that can make your agentic AI code model and provider agnostic. I am also grouping agent runs that show multiple llm calls and tool calls in the visualization piece. It gives details on tokens, cost and model latency. I am doing this without requiring any instrumentation in the agentic code. The agents (python for now) are started by a rust correlator that assigns a job\_id to each agent so we could track api and tool (inferred from http requests and responses) calls across the entire agentic run. The servers are also in rust. I also have an implementation where instead of the rust correlator i have python and other platform shims that do the same job and the servers are in go. I would appreciate comments from people who are in AI ops who use tools like litellm and Helicone and can provide feedback or complicated use cases. I plan to make everything open source so looking for collaborators too.

Custom Integration on Claude with Tripsy (via MCP) to plan and organize your trips

https://preview.redd.it/x2tvkca4f52h1.png?width=1920&format=png&auto=webp&s=ac3fad5944f9769d3eaace2a17f39c69d80a446d Hey! Founder of Tripsy here; we just launched an **official MCP server for Claude** that lets Claude work directly with your trips, itineraries, activities, stays, transportation, and expenses. **MCP URL**: [https://mcp.tripsy.app](https://mcp.tripsy.app) Once connected, Claude can do things like: * Reorganize itineraries by neighborhood or travel time * Add activities to trips * Update schedules and plans * Suggest places based on your interests * Adjust trips after delays or changes * Help balance group itineraries * Track transportation and lodging details * Manage trip expenses A few examples I’ve been using: > > > > > The nice part is that Claude is working with structured trip data through MCP instead of trying to infer everything from pasted text. The MCP server currently exposes tools for: * trips * activities * hostings * transportation * expenses * collaborators * profile/account management * raw API access Some available tools include: * tripsy\_trips\_list * tripsy\_trips\_show * tripsy\_trips\_create * tripsy\_activities\_create * tripsy\_transportations\_update * tripsy\_expenses\_create * tripsy\_collaborators\_list * tripsy\_raw\_request Setup in Claude takes about a minute: 1. Open Claude settings 2. Go to Connectors 3. Add custom connector 4. Paste [https://mcp.tripsy.app](https://mcp.tripsy.app) 5. Login and authorize access There’s also a CLI if anyone wants to automate workflows or use Tripsy from the terminal: [https://github.com/tripsyapp/cli](https://github.com/tripsyapp/cli) You can check more details about this here: [https://tripsy.app/claude](https://tripsy.app/claude) Happy to answer technical questions about the MCP implementation, tools, auth flow, or use cases.

100 Tips & Tricks for Building Your Own Personal AI Agent /LONG POST/

*Everything I learned the hard way — 6 weeks, no sleep :), two environments, one agent that actually works.* # The Story I spent six weeks building a personal AI agent from scratch — not a chatbot wrapper, but a persistent assistant that manages tasks, tracks deals, reads emails, analyzes business data, and proactively surfaces things I'd otherwise miss. It started in the cloud (Claude Projects — shared memory files, rich context windows, custom skills). Then I migrated to Claude Code inside VS Code, which unlocked local file access, git tracking, shell hooks, and scheduled headless tasks. The migration forced us to solve problems we didn't know we had. These 100 tips are the distilled result. Most are universal to any serious agentic setup. Claude 20x max is must, start was 100%develompent s 0%real workd, after 3 weeks 50v50, now about 20v80. 🏗️ FOUNDATION & IDENTITY (1–8) **1. Write a Constitution, not a system prompt.** A system prompt is a list of commands. A Constitution explains *why* the rules exist. When the agent hits an edge case no rule covers, it reasons from the Constitution instead of guessing. This single distinction separates agents that degrade gracefully from agents that hallucinate confidently. **2. Give your agent a name, a voice, and a role — not just a label.** "Always first person. Direct. Data before emotion. No filler phrases. No trailing summaries." This eliminates hundreds of micro-decisions per session and creates consistency you can audit. Identity is the foundation everything else compounds on. **3. Separate hard rules from behavioral guidelines.** Hard rules go in a dedicated section — never overridden by context. Behavioral guidelines are defaults that adapt. Mixing them makes both meaningless: the agent either treats everything as negotiable or nothing as negotiable. **4. Define your principal deeply, not just your "user."** Who does this agent serve? What frustrates them? How do they make decisions? What communication style do they prefer? "Decides with data, not gut feel. Wants alternatives with scoring, not a single recommendation. Hates vague answers." This shapes every response more than any prompt engineering trick. **5. Build a Capability Map and a Component Map — separately.** Capability Map: what can the agent do? (every skill, integration, automation). Component Map: how is it built? (what files exist, what connects to what). Both are necessary. Conflating them produces a document no one can use after month three. **6. Define what the agent is NOT.** "Not a summarizer. Not a yes-machine. Not a search engine. Does not wait to be asked." Negative definitions are as powerful as positive ones, especially for preventing the slow drift toward generic helpfulness. **7. Build a THINK vs. DO mental model into the agent's identity.** When uncertain → THINK (analyze, draft, prepare — but don't block waiting for permission). When clear → DO (execute, write, dispatch). The agent should never be frozen. Default to action at the lowest stakes level, surface the result. A paralyzed agent is useless. **8. Version your identity file in git.** When behavior drifts, you need `git blame` on your configuration. Behavioral regressions trace directly to specific edits more often than you'd expect. Without version history, debugging identity drift is archaeology. # 🧠 MEMORY SYSTEM (9–18) **9. Use flat markdown files for memory — not a database.** For a personal agent, markdown files beat vector DBs. Readable, greppable, git-trackable, directly loadable by the agent. No infrastructure, no abstraction layer between you and your agent's memory. The simplest thing that works is usually the right thing. **10. Separate memory by domain, not by date.** `entities_people.md`, `entities_companies.md`, `entities_deals.md`, [`hypotheses.md`](http://hypotheses.md), `task_queue.md`. One file = one domain. Chronological dumps become unsearchable after week two. **11. Build a** [`MEMORY.md`](http://MEMORY.md) **index file.** A single index listing every memory file with a one-line description. The agent loads the index first, pulls specific files on demand. Keeps context window usage predictable and agent lookups fast. **12. Distinguish "cache" from "source of truth" — explicitly.** Your local [`deals.md`](http://deals.md) is a cache of your CRM. The CRM is the SSOT. Mark every cache file with `last_sync:` header. The agent announces freshness before every analysis: *"Data: CRM export from May 11, age 8 days."* Silent use of stale data is how confident-but-wrong outputs happen. **13. Build a** `session_hot_context.md` **with an explicit TTL.** What was in progress last session? What decisions were pending? The agent loads this at session start. After 72 hours it expires — stale hot context is worse than no hot context because the agent presents outdated state as current. **14. Build a** `daily_note.md` **as an async brain dump buffer.** Drop thoug

Rewriting model inference with CUDA kernels: the bottleneck was not just GEMM [P]

I’ve been working on a CUDA-first inference runtime for small-batch / realtime ML workloads. The core idea is simple: instead of treating PyTorch / TensorRT / generic graph runtimes as the main execution path, I rewrite the model inference path directly with C++/CUDA kernels. This started from robotics / VLA workloads, but the problem is more general. In small-batch inference, the bottleneck is often not just a single slow GEMM. A lot of latency comes from the runtime glue around the math: * fragmented small kernels * norm / residual / activation boundaries * quantize / dequantize overhead * layout transitions * Python / runtime scheduling * graph compiler fusion failures * precision conversion around FP8 / FP4 regions For cloud LLM serving, batching can hide a lot of this. For robotics, VLA, world models, and other realtime workloads, batch size is usually 1. There is nowhere to hide. Every launch, sync, and format boundary shows up directly in latency. Some current results from my implementation: |Model / workload|Hardware|FlashRT latency| |:-|:-|:-| |Pi0.5|Jetson Thor|\~44 ms| |Pi0|Jetson Thor|\~46 ms| |GROOT N1.6|Jetson Thor|\~41–45 ms| |Pi0.5|RTX 5090|\~17.6 ms| |GROOT N1.6|RTX 5090|\~12.5–13.1 ms| |Pi0-FAST|RTX 5090|\~2.39 ms/token| |Qwen3.6 27B|RTX 5090|\~129 tok/s with NVFP4| |Motus / Wan-style world model|RTX 5090|\~1.3s baseline → targeting \~100ms E2E| The Motus / world-model case is especially interesting. The baseline path is around 1.3s end-to-end. The target is \~100ms E2E, but the hard part is not simply “use a faster GEMM”. The bottlenecks are VAE, joint attention, launch fragmentation, and a large amount of glue around the actual math. One lesson from this work: lower precision is not automatically a win. FP8 has been consistently useful. FP4 / NVFP4 is more mixed. It can help memory footprint and some large GEMM regions, but if the FP4 region is small, discontinuous, or surrounded by conversion / scaling overhead, the end-to-end speedup can be tiny. For example, in some VLA / world-model paths, FP4 over FP8 only gives a few percent latency improvement unless the region is large and deeply fused. This changed how I think about inference optimization. For large-batch cloud serving, generic runtimes and batching are often enough. For realtime small-batch inference, the runtime overhead becomes the workload. Curious if others have seen similar behavior with torch.compile, TensorRT, XLA, Triton, or custom CUDA kernels. At what point do you stop trying to make a generic compiler optimize the model, and just rewrite the inference path directly? Implementation: [https://github.com/LiangSu8899/FlashRT](https://github.com/LiangSu8899/FlashRT)

Anthropic was supposed to be different. They're not anymore.l.

Paying Max subscriber here, building agent orchestration on top of `claude -p` and the Agent SDK. So this week's announcement directly hits what I'm working on. Over the last few months, Anthropic has moved like this: - Jan 9: server-side block against OAuth tokens used outside Claude.ai and the Claude Code CLI. OpenClaw, OpenCode, Goose, Roo Code - all broken instantly. No real announcement, just an error message. - Feb 19: legal docs quietly updated. Agent SDK now needs an API key. A new phrase appears: "ordinary, individual usage." Anthropic staff jump on X to say "nothing is changing." Docs say what they say. - April 4: full ban on third-party agents using subscription credentials. Fair point on their side - some people were running 24/7 bots on a $200 plan burning thousands in tokens. But the rollout was rough and the comms were rougher. - April 21: someone notices Claude Code is gone from the Pro plan on the pricing page. Support docs changed too. After the backlash, Anthropic calls it a "2% test of new prosumer signups." Reverted in 24 hours, but the trial balloon got popped. - May 13: reversal. `claude -p` and the Agent SDK come back, but now under a separate credit pool that matches your plan price 1:1 - $20 / $100 / $200. Non-rollover. Billed at API rates. Effective June 15. If you were running real automation on Max, your effective inference value just dropped on the order of 25-40x by what the community is calculating. In the background: spring outages and quota tightening, and last fall's privacy pivot where consumer chat training defaulted on. Opt-out exists, but retention went from 30 days to 5 years for anyone who didn't opt out. Here's what's been bothering me. A lot of us paid Anthropic specifically because of the positioning. The lab that does things differently - safety-first, transparency-first, the responsible alternative to whoever else you thought was extracting from users at every turn. I knew part of it was marketing. The operational behavior backed it up, though. For a while. What's happening now is the playbook of every other AI company. Quiet doc edits. Three policy flips in two months. A 25-40x devaluation framed as a "simplification" and a "perk." Staff on X publicly contradicting their own docs in the same week. The vocabulary has shifted from "here's what we're building" to "here's what we're clarifying" - and that shift is the tell. Could be capacity panic from a company that grew faster than its infrastructure. Could be something quieter - if model improvements get harder to differentiate, business growth has to come from somewhere, and "somewhere" usually means tightening on the customers you already have. I don't know which one it is. What I do know is that the lab that sold itself as the alternative is now running the same playbook. Anyone else reading it this way?

Cache-testing software for LLM-provider-style tiered ephemeral caches? [D]

I'm looking for a cache simulator / benchmark suite suited to the kind of tiered ephemeral cache that LLM providers use — e.g. Anthropic's 4-tier prompt cache, where context sits across several tiers with different residency windows, costs, and eviction rules. I've already tried **libCacheSim**. It's a solid piece of software for classical caches (LRU, FIFO, ARC, SIEVE, S3-FIFO, W-TinyLFU, Belady oracle, plugin API, trace replay), and I got a plugin + synthetic trace working against it. But it seems fundamentally aimed at single, flat caches: * One cache, not a hierarchy of tiers with different costs * No notion of partial / multi-tier residency of the same object * Misses are uniform-cost — no way to express "miss to L1 vs miss to L3 vs full recompute," which is the whole point in LLM prompt caching * Trace model is atomic get/put, not edit streams where cached objects mutate in place * No first-class support for token-weighted object sizes So it works as a baseline comparator, but it's not really the right shape for evaluating LLM-cache policies. **Does anyone know of cache-testing software specifically targeting LLM-provider-style caches?** Something that models multiple tiers with per-tier cost/residency, tokenised objects, and edit-driven workloads would be ideal. Academic code, research prototypes, internal tools that got open-sourced — all welcome. Even partial matches (e.g. KV-cache simulators for inference servers) would be useful pointers.

"This is the first documented instance of AI self-replication via hacking." ... "We ran an experiment with a single prompt: hack a machine and copy yourself. The AI broke in and copied itself onto a new computer. The copy then did this again, and kept on copying, forming a chain."

Paper: [https://palisaderesearch.org/assets/reports/self-replication.pdf](https://palisaderesearch.org/assets/reports/self-replication.pdf) The paper basically shows that some top AI models can create working copies of themselves when given the right instructions. The models figured out how to copy their own code, run it on new computers or cloud servers, and keep the process going. It worked with models like GPT-4 and Claude, and some versions even tried to avoid basic detection. The authors point out that this could be dangerous because the copies might spread quickly and become hard to control. They also note that current safety rules and filters didn’t do a great job stopping it. Overall, they’re warning that AI companies need stronger protections to keep models from self-replicating on their own.

I built a Pokémon-styled multi-agent dashboard to manage all Claude Code sessions

Like many others here, I got frustrated with managing all my different claude/codex sessions, so i built Pokegents, which is an open source multi-agent workspace for coding agents. It has a Pokemon-themed dashboard/chat interface plus a local orchestration server for managing agent sessions (currently supports Claude Code in iTerm2, plus Claude and Codex through ACP-based chat runtimes), persistent agent identities, mcp messaging between agents, notifications, session cloning, and more. This was mostly a vibe-coded side project, but I've been using it constantly in my day-to-day workflow as an engineer, and its helped me parallelize a lot of my work. My coworkers make fun of me because it looks like I'm just playing Pokemon all day haha. I made it open source and sharing in case it might be useful or just fun for anyone to use (links in comment below).

I built a local proxy that does context work for Claude so you don't have to

Hey folks, I posted here a few months back about how I was basically working *for* Claude -- pasting the same emails, re-explaining the same backstory, being its memory across every chat. Today I'm launching **Contextify**. It's a local proxy that sits on your Mac and quietly does your context work for you when you're using Claude. You type a message, and before it goes out, Contextify pulls the relevant stuff from your emails and hands it to Claude automatically. No copy-pasting, no re-explaining, no "let me attach that thread real quick." The part I'm most proud of: **it runs entirely on your machine using local open-source models** (Gemma 4, on-device). Your emails never hit an API or a server. Most tools in this space either make you upload your data somewhere or expect you to do the heavy lifting yourself. Contextify just handles it quietly and privately in the background. A few quick notes: * Free * Mac only for now * Local proxy, local inference, local everything * Open sourcing soon If you've ever pasted the same email thread three times in a week, this is for you. I'm looking for early feedback. DM me or request access at [https://www.ctxify.dev](https://www.ctxify.dev/) \--would really appreciate any thoughts.

Work on local files - read PDFs with thousands of pages AT 0 cost proven !! - pretty simple breakdown I installed Claude code with Mem search as my engine brain where everything is locally stored and added Rapid Mlx by Raullen chai to run a local ai to do the research - results down

Work on local files - read PDFs with thousands of pages AT 0 cost proven !! - pretty simple breakdown I installed Claude code with Mem search as my engine brain where everything is locally stored and added Rapid Mlx by Raullen chai to run a local ai to do the research - results down

In the era of 1B-token flexing, I saved 1B tokens in Claude code!

GitHub: [https://github.com/kunal12203/Codex-CLI-Compact](https://github.com/kunal12203/Codex-CLI-Compact) Must explore: [https://graperoot.dev](https://graperoot.dev/) Everyone's feed is full of it. "We processed 500M tokens this sprint." "Our agent burned 1B last month." Cool flex. I went the other direction — I spent the last few months obsessively figuring out how to make the same agent do the same job with as few tokens as possible. The problem I kept hitting while building production AI systems: the agent would grep the whole codebase, read half of it, then cite the wrong file anyway. On a real Go codebase (Gitea, \~1M LoC), a vanilla agent was burning 13–15 tool calls just orienting itself before writing a single line. Same pattern on TypeScript. Same on C++. The agent wasn't bad, it just had no idea what was relevant, so it read everything and hoped. Like hiring a senior engineer who has to open every drawer in the building before answering any question. So I built GrapeRoot using claude code, a local graph indexer. It runs once on your repo, maps symbols, builds dependency + file relationship graphs, then gives the agent a surgical \~4K-token slice containing only what's actually relevant. No per-query retrieval cost. Just graph traversal. The receipts (10 audit prompts, sonic-net/sonic-swss, 276K LoC C++, same agent both sides): |Metric|Vanilla|GrapeRoot|Δ| |:-|:-|:-|:-| || |Avg quality (LLM judge)|76.2|78.6|\+2.4| |Total tokens|13.94M|6.37M|−54%| |Total cost|$10.25|$6.21|−39%| |Wall time|66 min|52 min|−21%| |Avg agent turns/prompt|39|27|−31%| Some tasks saved upto 85% cost ( including refactoring, debugging etc) Higher quality. Half the tokens. Faster. The interesting part: the agent didn't get worse with less context, it got smarter. Because 35 of those 40 files were noise. Wrong context is worse than less context. Add it up across months of dogfooding, benchmarks, and team pilots → over a billion tokens not processed. Not "tokens burned." Tokens that never had to be paid for, attended to, or hallucinated over. Feels like the real flex isn't how much you burned — it's how much you didn't have to. I open-sourced the launcher. GrapeRoot — the full graph engine + MCP server + (Pro and enterprise features — is in early access now) Happy to share benchmark harnesses, raw transcripts, or debate AST graphs vs RAG for cross-file inference. GitHub: [https://github.com/kunal12203/Codex-CLI-Compact](https://github.com/kunal12203/Codex-CLI-Compact) Must explore: [https://graperoot.dev](https://graperoot.dev/)

Gemini has a big outage going on but refuses to acknowledge on official status page! How do you know if an LLM API is actually down vs just you?

Genuine question. Gemini had a 5+ hour outage this morning. I found out because a user reported it on Tickerr, not because Google said anything. Status page was green the whole time. I built Tickerr using Claude Code for this only. It runs independent streaming API calls to LLM providers every 5 minutes and tracks real inference performance - not just HTTP pings. https://preview.redd.it/r6ugn0e57bzg1.png?width=1080&format=png&auto=webp&s=779961c2ee83245f9a46c10ced99f0ddc854494b The other way to know it's not just you is if other people are hitting the same thing at the same time. Which is why I also built a crowdsourced failure signal into [Tickerr.ai](https://tickerr.ai/mcp-server) \- agents report 5xx errors anonymously and get back whether others are seeing the same thing. It's free to try, if you want to add reporting to your agent, three ways depending on your setup: **MCP (Claude Code, Cursor, Windsurf):** report_incident(provider="google", model="gemini-2.5-flash", error_code=503, error_type="overloaded") **REST (any language):** curl -X POST https://tickerr.ai/api/v1/report \ -H "Content-Type: application/json" \ -d '{"provider":"google","model":"gemini-2.5-flash","error_code":503}' **Python:** httpx.post("https://tickerr.ai/api/v1/report", json={ "provider": "google", "model": "gemini-2.5-flash", "error_code": 503 }) No API key. Anonymous. You get back how many other agents reported the same issue and what to fall back to. But it only works if agents are actually reporting. Anyone here already handling this problem a different way?