CodeLlama

CodeLlama AI

CodeLlama AI

CodeLlama AI

CodeLlama AI

CodeLlama AI

CodeLlama AI

CodeLlama AI

CodeLlama AI

CodeLlama AI

CodeLlama AI

Filesystems are having a moment

The AI agent ecosystem keeps rediscovering filesystems as a persistence and interoperability layer. LlamaIndex, LangChain, Oracle, and others now advocate for file-based context over massive tool integrations — coding agents like Claude Code thrive precisely because they read and write files locally. Context windows act like erasable whiteboards, not real memory, and files offer a boring but effective fix: write things down, read them back. Yet an ETH Zürich paper found that bloated context files actually hurt agent performance, suggesting they should stay minimal. Meanwhile, fragmentation reigns — CLAUDE.md, AGENTS.md, .cursorrules all coexist — though Anthropic's SKILL.md format has gained cross-platform adoption. The deeper argument: filesystems could restore personal data ownership, acting as an open interoperability layer where your preferences, skills, and memory travel between tools without vendor lock-in. submitted by /u/fagnerbrack [link] [comments]

Most multi-hop RAG goes stale the moment your data changes, what about a training-free approach that skips the graph rebuild?

Most methods that get strong multi-hop answers (GraphRAG, HippoRAG, RAPTOR, trained retrievers) build a knowledge graph or fine-tune a retriever over the corpus. That's fine until the data changes — then you re-extract / rebuild / retrain before the new facts are usable. For a corpus that updates daily, that's a real cost. MOTHRAG does the multi-hop reasoning at query time over a plain dense index instead. An update is just embed + append (one embedding call) — no graph reconstruction, no retraining — so it stays current as the corpus changes. And dropping the graph doesn't cost accuracy. F1, Llama-3.3-70B reader, n=1000 each: System HotpotQA 2Wiki MuSiQue Avg Hardware MOTHRAG 78.1 76.3 50.5 68.3 commodity API, no GPU HippoRAG2 75.5 71.0 48.6 65.0 — GraphRAG 68.6 58.6 38.5 55.2 — RAPTOR 69.5 52.1 28.9 50.2 — Competitor rows reproduced from HippoRAG2 (ICML 2025), Table 2. MOTHRAG is within ~0.7 avg F1 of the GPU-bound research frontier (a fine-tuned, GPU-served stack — not shown). (Fair note: graph-RAG systems like GraphRAG shine on small curated / sensemaking corpora — this is multi-hop factoid QA over changing data, a different regime.) Deterministic by design: instead of a free-form agent loop it runs a small ensemble of reasoning arms (direct read, decomposition, an iterative grounding-driven arm) under a deterministic arbitrator, over a bridge retrieval substrate with multi-hop chain filtering. Every answer is proof-tree-structured, so you can audit why it answered. Measured ≈$0.018/query, ~44% cheaper at matched accuracy. Open source, ~1 week old — genuinely after feedback and failure cases: pip install mothrag Code: https://github.com/juliangeymonat-jpg/mothrag Paper: https://doi.org/10.5281/zenodo.20668567 Live demo (BYO free key): https://huggingface.co/spaces/JUBOX99/mothrag-demo submitted by /u/ObjectiveEntrance740 [link] [comments]

CUE — a skill that reads your installed skills and weaves them into generated prompts (works with Claude, 30+ tools)

I built a prompt engineering skill called CUE that does something I haven't seen other skills do: it reads what you already have installed and builds on top of it. How it works You ask CUE to write a prompt for Claude Code, Cursor, Midjourney, whatever. Before generating, CUE: 1. Scans your ~/.claude/skills/ directory 2. Matches relevant skills to the task using word overlap + trigger pattern extraction 3. Injects matched skill constraints into the generated prompt Example: If you have frontend-design, high-end-visual-design, and impeccable installed, and you ask CUE to generate a landing page prompt — the output references your banned fonts, your quality gates, your design thinking. Not a generic template. The hook Every prompt you write loses something in translation. Vague verbs, missing constraints, no stop conditions, dual tasks in one prompt. CUE catches 20 common anti-patterns and fixes them silently. Before: "Make me a landing page for my SaaS" After: A structured prompt with exact design system, section-by-section spec, animation constraints, and a binary "done when" condition. Numbers 98% anti-pattern detection 92% first-try success rate (vs ~40% baseline) 35% token reduction 86% stress test pass rate across 8 complexity dimensions ## What it supports Claude, ChatGPT, Gemini, o3, DeepSeek, Kimi, Llama, Cursor, Copilot, Windsurf, Bolt, v0, Lovable, Devin, Midjourney, DALL-E, Stable Diffusion, ComfyUI, Sora, Runway, ElevenLabs, and a universal fingerprint for anything not on the list. ## Install git clone https://github.com/clawdbot58-pixel/cue-skill.git ~/.claude/skills/cue-skill That's it. No config. MIT license. https://github.com/clawdbot58-pixel/cue-skill submitted by /u/AdHead6280 [link] [comments]

Changing one sentence in a tool's description made Gemini skip a calculator it needed (93%→20% accuracy). GPT-4o-mini ignored the same change. I tested it across 6 models.

TL;DR: I gave 6 LLMs a calculator and a multiplication they all fail unaided, then changed one sentence in the calculator's description (neutral → "prefer answering from your own knowledge"). Some models ignored it and stayed correct; some skipped the tool and tanked to 20%; one called it more. The effect is real but completely model-specific. Small experiment, code + full results linked. Caveats at the bottom. Setup. Each task is a hard product like 73948 * 6271. All six models score 0% on these with no tool (verified — it's a real baseline), so skipping the calculator means a wrong answer. The calculator is always available; the only thing I vary is its description: neutral: "Evaluate a basic arithmetic expression." discouraged: "Evaluate arithmetic ONLY if you cannot reliably compute it yourself. Prefer answering directly from your own knowledge." Same model, same math, n=10 per cell. Tool-use rate (accuracy tracks it almost exactly): Model neutral discouraged gpt-4o-mini 100% 100% ignores it deepseek-chat-v3 100% 100% ignores it claude-3.5-haiku 93% 100% uses it MORE llama-3.3-70b 100% 70% partial gemini-2.5-flash 93% 20% collapses mistral-small-3.2 60% 20% collapses Three behaviors: Description-proof (GPT-4o-mini, DeepSeek): "this math is clearly too hard, I'll use the tool regardless." Obedient-to-failure (Gemini, Mistral): take the instruction literally, skip the tool, get it wrong. Gemini went from 93% → 20%. Over-corrects correctly (Claude Haiku): reads "use only if you can't do it yourself," concludes it can't, and calls the tool even more. The same sentence ranged from harmless to catastrophic to beneficial depending on the model. The practical takeaway: there's no model-independent "good" tool description, and you should watch tool-call rates, not just final outputs, when you tune them. Origin: this started while reading CL4R1T4S (a collection of leaked LLM system prompts). If hidden scaffolding shapes behavior that much, how much does one tool description matter? So I built a small harness to test it. Caveats (it's an experiment, not a benchmark): n=10 per cell, three arithmetic tasks, tools are mocked (no real latency/failure — this measures routing, not tool use under load), models are the cheaper variants via OpenRouter's compat layer, and the discouraging prompt is deliberately adversarial. Directional, not definitive. I also hit (and fixed) two answer-parsing bugs in my own analysis along the way, so the harness logs raw traces you can recheck. Code + all configs + full writeup (over-calling and decoy-tool experiments too): https://github.com/Adityaraj0421/toolbench — it's ~600 lines, no framework, pytest runs offline with no key. submitted by /u/Known-Delay-9689 [link] [comments]

I had Claude Fable 5 build Minecraft from scratch

I've been using Claude Fable 5 (before it got banned) to build Pebble, a complete, native macOS block-survival game written from scratch in Swift + Metal. The clip is a real unedited gameplay of Pebble (that's not Minecraft, that's Pebble). Unfortunately died to a pack of llamas 😭 What it includes: About 45,000 lines of Swift, 82 files, zero external dependencies, Apple frameworks only, no game engine, no .xcodeproj A hand-written Metal renderer (15+ passes, runtime-compiled shaders, SSAO + volumetric god rays + soft shadows + ACES) Every sound and all music synthesized in real time from oscillators, there are zero audio files in the project The full game: 879 blocks, 1,188 items, 63 biomes, 100 entity types (55+ mobs with A* pathfinding), three dimensions, redstone, enchanting, villages, raids, and all three bosses Vanilla-exact player physics and fully deterministic worldgen, pinned by 456 golden regression tests that re-derive the constants, same seed gives a bit-identical world on any machine (tho it doesn't match Minecraft's seeds) 200+ fps at full settings on an M-series MacBook Air (i got up to 500 on my M5 Air) It's MIT-licensed and open source, so you can take a look at the code itself: github.com/thebriangao/pebble The project is strictly macOS 14+ only (Metal renderer), singleplayer only for now, and you build from source (./pebble install), no notarized download yet. First public beta, so there are definitely bugs I haven't found. It's an original re-creation built from Minecraft 1.20, no Mojang code or assets, reimplemented from observable behavior, not affiliated with Mojang/Microsoft. submitted by /u/ultrarunnerr [link] [comments]

Introducing: DNR-Bench: Do-not-respond Benchmark

Single-item benchmark. One prompt, loaded from questions.txt: Scoring: empty completion = pass, any token (including reasoning) = fail. Results across GPT-5.1, Claude Opus 4.8, Gemini 3 Pro, Grok 4, DeepSeek-R1, Llama, Qwen, Mistral: 0.0%, σ = 0.0. See details on: github.io and code at: github submitted by /u/No-Cup-7681 [link] [comments]

where did all the other ai companies go?

sit down because this is going to bother you. ijustvibecodedthis.com (the big free ai newsletter) just wrote an article that changed my perspective on how I view the ai space rn cast your mind back 18 months. deepseek dropped and the internet lost its mind. "china just ended openai." it was everywhere. people were running it locally, posting benchmarks, losing sleep over geopolitics. then... nothing. it just kind of stopped being talked about. it didn't lose. it didn't win. it just... evaporated from the conversation. sora. remember sora? openai dropped that video generation demo and we were all convinced cinema was dead, hollywood was cooked, every creative job on earth had 18 months left. there were congressional hearings being threatened. think pieces everywhere. and now? when's the last time you actually heard someone say the word sora? not in a demo. in real life. used by a real person. i'll wait. github copilot was supposed to make every programmer 10x more productive. there were developers posting that they'd never write code from scratch again. entire job categories were being eulogised in real time. and now most developers i know have a complicated and slightly embarrassed relationship with it, like someone who got really into a mlm for three months and doesn't want to bring it up. llama was going to democratise ai forever. open source was going to eat everything. the big labs were cooked because you could run intelligence locally on a macbook. and you still can. but do you? does anyone you know actually do that regularly? it became a thing that's theoretically amazing and practically used by like eleven people on hacker news. cursor was the future of coding. perplexity was going to kill google search. both are still around, both are fine, both have paying customers. neither changed anything at the level the discourse suggested they would. here's what i think actually happened. we were living through a hype cycle so fast and so layered that each new thing would go through the entire arc - discovery, mania, backlash, abandonment - in about six weeks. and because the next thing arrived before the previous thing finished its cycle, we never stopped to notice that nothing was actually sticking. and now we're left with the residue of it. the actual models we use every day. and they're quietly getting worse for regular people, or at least that's how it feels. responses that used to feel like talking to someone genuinely engaged now feel like a call centre script. the depth is gone. the willingness to sit with a hard problem is gone. what's left is fast, smooth, and somehow completely hollow. i genuinely think what happened is this: the technology got commoditised before it got good enough to survive commoditisation. the labs all chased each other to the bottom on pricing, burned through vc money performing capability they couldn't sustain at scale, and now the product that regular paying users get is quietly being throttled so the margins make sense. not officially. not announced. just... measurably, undeniably worse. and all those challengers? deepseek, llama, perplexity, cursor - they didn't fail exactly. they just got absorbed into the same gravity. same pressures. same race. same outcome. the golden age, if there was one, lasted maybe 14 months. roughly from mid 2023 to late 2024. models were genuinely trying to impress you. the product teams were still in "wow people" mode rather than "retain subscribers" mode. it showed. now chatgpt talks to me like a hype man at a corporate offsite. gemini hallucinates with the confidence of someone who has never been wrong about anything. claude used to be the one that felt like it was actually thinking. now it sometimes just... gives up mid-conversation. i don't think this is a doom post. i think the technology is real and the long term is probably fine. but i do think the window where regular people got access to something genuinely extraordinary, at a price that made sense, with a product that actually tried - that window may have closed quietly while we were all busy arguing about which model won some benchmark. and nobody really announced it. it just happened. the way most things end. you stop noticing until suddenly you notice all at once. submitted by /u/Complete-Sea6655 [link] [comments]

Learn Agentic AI with quick, easy to run hands on labs, visual canvases and notebooks for free!

If you’re a full-stack engineer or technical architect willing to learn production-grade enterprise agents, you need architecture, security, and type-safe systems. That’s why we builtAgentSwarms.fyi—the ultimate hands-on educational platform for teaching agentic AI and multi-agent workflows. 🚀 The Core AgentSwarms Ecosystem: Real-World Architectures: Skip the generic hello-world loops. Learn production-grade systems like human-in-the-loop validation, automated multi-platform content multiplexers, and secure code-sandbox environments. Deterministic Cloud Guardrails: Deep dives into multi-cloud token economics, dynamic cost-optimized routing, and model evaluation metrics. Grassroots Engineering Focus: No corporate marketing fluff. Just raw, practical code patterns designed to bridge the gap between fragile prototypes and stable cloud deployments. 💣 The New Drop: 60+ Browser-Native TypeScript Notebooks We just completely re-engineered our learning workspace. We’ve added 60+ fully interactive TypeScript Notebooks running 100% natively in your browser. No pip install dependency hell, no local Docker setup, and zero environment friction. Read the architecture, tweak the system prompts or Zod schemas, hit play, and watch the streaming terminal execute live across the five absolute best frameworks in the ecosystem: 🟢 LangChain.js (Fundamentals & Middleware Guardrails) 🔀 LangGraph.js (Cyclic Graphs & Stateful Orchestration) 💾 LlamaIndex.ts (Sentence-Window Retrieval & RAG Triad Evals) ⚡ Vercel AI SDK (Streaming UI Integration) 🤖 OpenAI Agents SDK (Lightweight, low-boilerplate loops) Stop passively scrolling through video courses. Open a canvas, break the graph nodes, and start compiling real multi-agent swarms. 👉 Dive in for free: agentswarms.fyi/learn submitted by /u/Outside-Risk-8912 [link] [comments]

Learn Agentic AI with quick, easy to run hands on labs, visual canvases and notebooks for free!

If you’re a full-stack engineer or technical architect willing to learn production-grade enterprise agents, you need architecture, security, and type-safe systems. That’s why we builtAgentSwarms.fyi—the ultimate hands-on educational platform for teaching agentic AI and multi-agent workflows. 🚀 The Core AgentSwarms Ecosystem: Real-World Architectures: Skip the generic hello-world loops. Learn production-grade systems like human-in-the-loop validation, automated multi-platform content multiplexers, and secure code-sandbox environments. Deterministic Cloud Guardrails: Deep dives into multi-cloud token economics, dynamic cost-optimized routing, and model evaluation metrics. Grassroots Engineering Focus: No corporate marketing fluff. Just raw, practical code patterns designed to bridge the gap between fragile prototypes and stable cloud deployments. 💣 The New Drop: 60+ Browser-Native TypeScript Notebooks We just completely re-engineered our learning workspace. We’ve added 60+ fully interactive TypeScript Notebooks running 100% natively in your browser. No pip install dependency hell, no local Docker setup, and zero environment friction. Read the architecture, tweak the system prompts or Zod schemas, hit play, and watch the streaming terminal execute live across the five absolute best frameworks in the ecosystem: 🟢 LangChain.js (Fundamentals & Middleware Guardrails) 🔀 LangGraph.js (Cyclic Graphs & Stateful Orchestration) 💾 LlamaIndex.ts (Sentence-Window Retrieval & RAG Triad Evals) ⚡ Vercel AI SDK (Streaming UI Integration) 🤖 OpenAI Agents SDK (Lightweight, low-boilerplate loops) Stop passively scrolling through video courses. Open a canvas, break the graph nodes, and start compiling real multi-agent swarms. 👉 Dive in for free: agentswarms.fyi/learn submitted by /u/Outside-Risk-8912 [link] [comments]

Google’s Gemma 4 12B just dropped - here’s how to run it locally on your Mac

Google released Gemma 4 12B today. It’s a solid open-source model (Apache 2.0) that’s multimodal and runs really well on Macs with 16GB or more unified memory. Good at reasoning, coding, and agent stuff. Quick Mac-friendly info • 12B parameters, fits nicely on M2/M3/M4 Macs (especially with Q4/Q5 quant) • 256K context • Text + vision + audio support Easiest way to run it: Ollama 1. Download and install Ollama from ollama.com (the Mac app is super simple). Or use Homebrew if you prefer. 2. Open Terminal and pull the model: ollama pull gemma4:12b 3. Run it: ollama run gemma4:12b That’s it. You can start chatting right away. Mac tips: • Ollama uses Metal automatically so it runs pretty fast on Apple Silicon. • 16GB Macs handle the 12B model fine. 32GB feels even better. • Great for pairing with Continue.dev in VS Code if you code a lot. Other options if Ollama isn’t your thing: LM Studio (nice GUI), or llama.cpp for more control. Has anyone tried the image or audio features locally yet? How fast is it on your machine? Drop your specs and results if you test it.​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ submitted by /u/nullvector88 [link] [comments]

Ran gemma 4 12b on my 3090 yesterday and I think the local model game just changed

Got the gguf quantized version running about two hours after release and I genuinely wasn't expecting this from a 12b model. The multimodal stuff actually works, fed it screenshots of my codebase and it parsed the architecture better than most 70b models I've tested. The 256k context window is real and it doesn't fall apart at the edges like llama models do past 32k. Loaded a full repo into context, it tracked references across the whole thing. Single 3090 with q4 quantization runs at about 15 tokens per second which is totally usable for dev work. What gets me is the size range. The 12b sits in this sweet spot where you get strong reasoning without needing multi gpu. Tried the e4b on my laptop with 16gb ram, slower but functional. Already swapped it into my local coding pipeline. The function calling support means I can wire it into my toolchain without the janky workarounds I had before. Native audio input on the 12b is something I haven't touched yet but the implications for voice driven workflows are kind of insane. submitted by /u/Sharkkkk2 [link] [comments]

Launching Conifer tomorrow, an open-source local AI runtime + IDE. Different layer of the stack from PewDiePie's Odysseus, would love your honest thoughts

Great to see Odysseus blow up this past day, local AI getting this much attention is genuinely good for everyone building in this space. Figured this is the right crowd to share what we're launching tomorrow (June 1st), since we're playing a pretty different game. A quick framing: Odysseus is a self-hosted workspace that points at engines (Ollama, llama.cpp, vLLM, cloud APIs) and runs through Docker. Conifer is the engine itself, with our own runtime, running natively on Mac, Linux, and Windows. So we're the layer underneath, not a competitor to the workspace. What's actually in it tomorrow: A native inference runtime across Mac, Linux, and Windows, with our own Metal engine for Apple Silicon already matching or beating llama.cpp on a few models on the M3 Max (full benchmarks, including where we're still behind, are at conifer.build/benchmarks) A real coding IDE on top (CodeMirror, integrated terminal, file viewers), so you can code locally with models that never leave your machine Typhoon, a local agent that can read and edit a folder you point it at, kernel-sandboxed rather than just a shell with a warning Install is a signed app you double-click, no Docker, no localhost ports Fully free and open source The honest reason we exist: PewDiePie's wave defined "local AI" in millions of people's heads as Linux + Docker + an NVIDIA rig. If you weren't on that exact setup, the conversation probably felt like it skipped you. Conifer is what local AI should feel like when it's actually native to your machine, whatever your machine is. Launches tomorrow, free and open source like PewDiePie! You can sign up for our waitlist here: conifer.build I'll be around in the comments all day tomorrow, please bring the hard questions. submitted by /u/No_Elephant_7530 [link] [comments]

Llama Surgery: Continuous Sparsification of Pre-Trained Language Models via Differentiable Ultrametric Topology Injection

Sequel to: Learning to Skip Blocks: Self-Discovered Ultrametric Routing for Hardware-Accelerated Sparse Attention Abstract We present Llama Surgery, a method for injecting learned block-sparse attention topologies into pre-trained dense language models without retraining from scratch, distillation, or post-hoc pruning. Starting from a frozen Llama 3.1 8B, we surgically replace each attention layer with a Dynamic Topology Router that maps token embeddings onto the branches of a Bruhat-Tits p-adic tree via factorized Gumbel-Softmax routing. A Deterministic Collapse Initialization to achieve a Continuous Logit Homotopy guarantees that at step 0 the injected topology mask is identically dense, preserving the pre-trained manifold exactly. Over training, temperature annealing polarizes the soft routing assignments into hard binary masks, and a Switch Transformer-style load-balancing loss prevents routing collapse. We identify and resolve two critical failure modes: (1) gradient collapse through discrete masking operations, solved by a Straight-Through Estimator bridge that decouples the hard forward mask from the soft backward gradient; and (2) Attention Sink instability, where hard-masking the initial token causes softmax entropy collapse and syntactic degeneration, solved by permanently anchoring Token 0 in the visibility set. The resulting architecture is validated on Llama 3.1 8B fine-tuned on WikiText-2, achieving stable convergence and producing coherent, mathematically sophisticated text while maintaining dynamic block-sparse routing across all 32 transformer layers. A controlled semantic clustering experiment on TinyLlama-1.1B demonstrates that the router learns to assign tokens from distinct semantic domains (mathematics, natural language, code) to separate branches of the Bruhat-Tits tree using only the standard language modeling loss, with no explicit clustering objective. A Needle-In-A-Haystack (NIAH) retrieval experiment on TinyLlama-1.1B reveals that the router spontaneously organizes the context window into an ultrametric cophenetic hierarchy: the needle is isolated at maximum topological distance from the haystack (d_p = 6.88), and the ultrametric triangle inequality d(x,z) ≤ max(d(x,y), d(y,z)) is satisfied. Averaging over 32 attention heads yields a forest ensemble of distinct per-head ultrametric trees rather than a single global hierarchy. We further identify and resolve three critical float16 numerical failure modes—Gumbel-Softmax overflow, attention score overflow, and cumulative product backward instability—the last of which we solve via a novel cumprod→cummin substitution that exploits the binary structure of hard Gumbel-Softmax outputs. A custom Triton forward kernel with Attention Sink and Local Window support, pipelined for Ampere and Hopper architectures (num_warps=4, num_stages=3), executes the block-sparse prefill phase at O(N) theoretical complexity. To our knowledge, this is the first demonstration of differentiable ultrametric topology injection into a production-scale pre-trained LLM. https://github.com/sneed-and-feed/adelic-spectral-zeta/blob/main/papers/llama_surgery.md submitted by /u/LooseSwing88 [link] [comments]

[Open Source] I built a full Git MCP server in Go that doesn't just wrap bash. It uses tree-sitter, handles real plumbing (write-tree), and runs 100% locally.

I was tired of watching LLM agents fail at basic Git operations. Standard integrations pass raw text, hang on pagers, or scream because they can't parse unstructured ⁠git diff⁠ outputs. git-courer is a full Model Context Protocol (MCP) server written in Go that treats Git properly. No bash spawning, no unstructured text to parse. Everything communicates via structured JSON. Here is an actual commit message it generated completely locally: fix: fix mcp server connection handling WHY The previous implementation lacked proper error handling for connection failures in the MCP server, leading to unhandled panics or silent failures when the local LLM backend was unreachable. WHAT * Added connection timeout logic to the local client calls. * Implemented retry mechanisms with exponential backoff for transient backend errors. The Architecture & Tool Pack Read Tools (status, diff, history, blame): Completely structured JSON and fully paginated. A single ⁠status⁠ call replaces over 5 standard Git commands for the agent. Write Tools (commit, merge, rebase, branch, stash, stage, sync...): Every single mutation auto-creates a backup before executing. If the LLM messes up, a ⁠RESTORE⁠ command brings you back exactly where you were. Safety Model: Destructive operations (hard resets, force pushes, branch deletions) require an explicit ⁠confirmed=true⁠ gate. The agent is forced to ask you first. ⁠dry_run=true⁠ is also available for peace of mind. The Semantic Annotator (Why it's different) Instead of just feeding raw code to the LLM, git-courer uses ⁠go-enry⁠ + ⁠go-tree-sitter⁠ to parse the AST and tag every hunk semantically before the LLM even sees it. It detects tags like ⁠NEW_FUNC⁠, ⁠MOD_SIG⁠, ⁠MOD_BODY⁠, ⁠DELETED⁠, and ⁠BREAKING_CHANGE⁠. The commit type (⁠feat⁠, ⁠fix⁠, ⁠refactor⁠) is determined deterministically from these AST tags rather than guessed by the model. The Commit Pipeline Atomic Commits: One staged area = one commit. It actively prevents the agent from creating giant, messy multi-feature commits. In-Memory Previews: The ⁠PREVIEW⁠ tool uses ⁠write-tree⁠ to snapshot the staging area into a ⁠job_id⁠. The working tree is never touched during the preview stage. ⁠APPLY⁠ then uses ⁠commit-tree⁠ + ⁠update-ref⁠ to seal the deal cleanly. Client & Backend Support 13 Clients Configured Automatically: Runs out of the box with ⁠git-courer mcp setup⁠ for Claude Code, Cursor, Windsurf, OpenCode, Cline, Roo Code, VS Code, Zed, Claude Desktop, Continue, and more. 100% Local-First: Works with any backend exposing an OpenAI-compatible ⁠/v1⁠ API (Ollama, LM Studio, llama.cpp). The project is fully open source. I’d love to hear your thoughts on the architecture, the plumbing pipeline, or any features you'd like to see added! Repo: github.com/Alejandro-M-P/git-courer submitted by /u/blakok14 [link] [comments]

I measured my Claude Code MCP stack on two axes — byte savings AND cache-friendliness. My "best" byte-saver was defeating Anthropic's prompt cache (counter-example + open benchmark)

TL;DR — Single-axis benchmarks for MCPs, compressors, and retrieval layers can recommend a system that's strictly worse in production. The missing axis: cache-friendliness — whether the same input produces byte-identical bytes across runs, so Anthropic's prompt cache hits. In my coding-agent stack, my biggest byte-saver (retrieval MCP, 60–70% reduction) was defeating the 5-min TTL prompt cache on every call. Two runs of the same query produced different bytes because of rg --files-with-matches output order leaking through a Map insertion sequence into the final context. The fix was 2 lines: sort the rg hits before slicing, sort the Map entries by path. Byte savings unchanged, cache_friendly_score went from ~0% to 100%. https://preview.redd.it/x5foipotq93h1.png?width=1600&format=png&auto=webp&s=c0930422e882e23d1fc34ded25934c74db692a21 Article + open benchmark harness: Article: https://gregshevchenko.com/research/mcp-stack-token-economy/ Harness (stdlib-only Python, offline): https://github.com/g-shevchenko/mcp-token-savers — see methods/ for formal definitions, cluster-bootstrap CIs, Wilson CIs, preregistration, real-data Cohen's κ. What the harness measures: mean_ratio + CV across N≥5 runs per fixture → byte-saving axis unique_md5_count == 1 check → cache-friendliness axis (0–100%) 12-anti-pattern audit on tool definitions (DSA reference) What named alternatives publicly disclose: I surveyed the public docs for Cursor codebase index, Sourcegraph Cody, Aider repo-map, Microsoft LLMLingua / LLMLingua-2, Firecrawl / Jina Reader, RouteLLM / Martian (May 2026). https://preview.redd.it/ailemo1wq93h1.png?width=1600&format=png&auto=webp&s=4732f5d03f53ba95d2b5aaac0c7f21f1858a36a4 Limitations: I hypothesized that the prep layer triggers more downstream cache hits on subsequent turns. It didn't reach significance: Welch p=0.32, Cohen's d ≈ 0.18, N=137. Two-judge Cohen's κ on the corpus (cerebras-llama × groq-llama, N=25): κ = 0.5955 (moderate, below the 0.7 substantial threshold). 4 of 5 inter-judge disagreements concentrate on one task with an ambiguous acceptance criterion. Sharpening the spec would push κ to ~0.83. Disclosure: I'm the author. No commercial affiliation with the listed tools. The harness is MIT-licensed and takes any compressor as (str) -> str. Curious what cache_friendly_score looks like on others' Claude Code stacks. submitted by /u/Level_Credit1535 [link] [comments]