Drift AI

Drift AI AI

Drift AI AI

Drift AI AI

Drift AI AI

Drift AI AI

Drift AI AI

Drift AI AI

Drift AI AI

Drift AI AI

Drift AI AI

PrintGuard 2.0 — ShuffleNetV2 + few-shot prototypical network, TFLite via LiteRT, ≈5 MB, runs unmodified in the browser (Pyodide) and on CPython [P]

Hi everyone, I shared PrintGuard here about a year ago as a few-shot FDM failure detector built on a ShuffleNetV2 backbone classified by a prototypical network — the model from my dissertation, packaged with a hub and a web UI. v2.0 ships today and is a complete rewrite of everything around the model, so I wanted to walk you through what's changed and what hasn't. What hasn't changed is the model. It's still a ShuffleNetV2 encoder classified by nearest prototype, trained for few-shot FDM fault detection in Edge-FDM-Fault-Detection (with a technical write-up in the repo). What has changed is the runtime: the model is now a ≈5 MB TFLite export via LiteRT, classified by nearest prototype, with per-printer sensitivity and threshold sliders that map directly onto the prototype distances — so you can tune for camera and lighting without retraining. The interesting bit for this sub is the architecture around the model. v2.0 is a single Python engine that runs unmodified on CPython (hub mode) and on Pyodide in the browser (local mode). Everything mode-specific is confined to one Platform implementation per runtime — the two modes cannot drift apart because they execute the same files. The methods on the Platform contract are exactly the ones that aren't portable: infer(rgb), discover_cameras(), open_camera(id, source), http(...), encode_jpeg(rgb), load_state / save_state. On the CPython side, infer is ai-edge-litert on CPU threads, discover_cameras walks the MediaMTX path list, and open_camera is a PyAV reader thread per RTSP stream. On the browser side, infer is LiteRT.js in WASM via a JS bridge, discover_cameras is enumerateDevices(), and open_camera is getUserMedia + canvas grabs. The UI is presentation-only and speaks one JSON command/event protocol — over a WebSocket in hub mode, over an in-page Pyodide bridge in local mode. The engine cannot tell which transport it is on. No mode-specific logic lives anywhere else; if a feature needs a runtime service, it extends the Platform contract on both sides. Inference scheduling is fully dynamic and fairness-aware: A smoothed estimate of observed inference latency continuously yields the sustainable total rate (workers / latency). That capacity is water-filled across in-use cameras (max-min fairness): no camera is allocated beyond its native fps, and surplus flows to cameras that can use it. A free worker takes the most overdue camera and grabs its freshest frame at dispatch time. Frames carry a sequence identity, so the same frame is never inferred twice, and results always describe the present, not a backlog. On RTSP, MediaMTX bursts the buffered GOP on connect, so stream fps is trusted from the SDP average_rate where available, and measured only after a warm-up otherwise. The defect pipeline is a monitor on top of a per-printer score stream. score ≥ threshold for N consecutive frames triggers the configured action (alert only, pause, or cancel) on the linked OctoPrint or Moonraker service, with retries on failure; the alert event carries the action and its outcome, the UI error feed gets a copy, and the snapshot goes out to every enabled notification channel (ntfy, Telegram, Discord). The fail-safe behaviour is the part I most want feedback on, because I have strong opinions about it. A printer's watching state gates inference: Linked service reports Watched? Why no service linked yes nothing to gate on printing yes the job needs eyes no state yet / unknown yes can't tell → watch offline (unreachable) yes losing the signal must not stop monitoring idle / paused / error no (standby) positively not printing Only a positive "not printing" stands inference down. The watchdog then warns on the dashboard and through notification channels when a camera drops, a feed freezes or a printer service stops answering, and a failed pause is announced, never swallowed. I'd be very interested to hear how this stance interacts with people who run multiple printers with mixed reliability on their printer services. There's a live browser demo (the whole engine in Pyodide + LiteRT.js WASM), the Docker image is multi-arch, and the architecture doc goes into all of the above in more detail with diagrams of the engine layout and the defect pipeline. This is a major version — nothing from 1.x migrates, and a 2.0 hub starts from a fresh configuration. Issues, especially around the fairness scheduler, the CORS / mixed-content / host.docker.internal edge cases, and the LiteRT ↔ Pyodide bridge, are very welcome. Let's keep failure detection open-source, local and accessible for all. submitted by /u/oliverbravery [link] [comments]

Building an Open Source Edge Semantic Cache for LLMs in Rust/WASM – Sanity check on the architecture? [D]

Hey everyone, I am planning out a new open-source infrastructure project and want to get some brutal feedback on the architecture and use-case validity from people running high volume LLM workloads in production. The Problem: Python-based proxies/gateways introduce too much latency overhead for real-time streaming agent steps or fast UI completions. Additionally, centralized semantic caching still suffers from cross-region network latency (e.g., London to us-east-1), and enterprise API costs remain a massive bottleneck for repetitive/predictable user queries (like customer support or structured data extraction). The Proposed Architecture: Instead of a heavy centralized gateway, the goal is to build a lightweight, zero-dependency semantic cache running directly at the CDN Edge using WebAssembly (WASM) compiled from Rust. The flow looks like this: Inbound Prompt: Hits the edge node closest to the user (e.g., Cloudflare Workers / Fastly Compute). Edge Embedding: The Rust/WASM module intercepts the raw text prompt and instantly generates a vector using an edge-native lightweight model (e.g., bge-small-en-v1.5). Similarity Index Check: It performs a fast cosine similarity check against an edge vector database (like Cloudflare Vectorize) to find the nearest semantic neighbor. Cache Hit: If similarity >= threshold (e.g., 0.88), it pulls the full generated response text from an edge KV store and returns it in ~5ms. The main LLM provider is never billed or touched. Cache Miss: It proxies the streaming request to OpenAI/Anthropic/vLLM, streams it back to the client, and asynchronously updates the edge vector index and KV store. Why Rust/WASM? To achieve sub-millisecond execution overhead on the proxy itself, avoid garbage collection pauses, and maintain a tiny memory footprint suitable for edge runtime constraints where traditional databases or Python scripts cannot run. My Questions for the Community: For those running LLMs in production (especially customer support, internal RAG, or autonomous agents), what is your realistic semantic cache hit rate? Is the power law of repetitive queries high enough in your domains to justify this? What are the biggest footguns with semantic caching at the edge? (e.g., Cache invalidation strategies, handling system prompt updates, or drift in embedding models). Would you actually use a drop-in open-source template/CLI that lets you spin this up on your own edge account, or do you prefer centralized API gateways? submitted by /u/Real-Huckleberry-934 [link] [comments]

I think AI agents are going to need an operating layer

The more autonomous AI systems become, the less I think individual security tools are enough. Right now we have agents with tool access, browser access, MCP servers, memory, workflows, external actions, and long running sessions. Most of the conversation is focused on models. I think the bigger problem is governance. Who approves high risk actions? How do you stop poisoned content from becoming instructions? How do you audit what happened after the fact? How do you track memory drift? How do you replay a failure? How do you enforce policy consistently across different models and agent frameworks? That’s why I’ve been building Bendex Arc. The idea is simple. Put a control plane between AI systems and real world actions. Arc Gate handles runtime governance. Arc Replay handles observability. Arc Approve handles human approval workflows. Arc Memory is focused on memory integrity. I don’t think the long term winner in AI will be the company with the most features. I think it will be the company that makes autonomous systems understandable, controllable, and auditable. I’m curious if others building agents think we’re heading toward a future where every serious deployment has a governance layer the same way every serious application has logging, monitoring, and access controls. Demo: https://web-production-6e47f.up.railway.app/demo GitHub: https://github.com/9hannahnine-jpg/arc-gate submitted by /u/Turbulent-Tap6723 [link] [comments]

A Fable 5 Success Story

Hi folks! I wanted to share my Fable 5 success story from yesterday. I've been building a passion project for about 8 months called Nora Kinetics (check out the trailer here if you're interested) a fully custom GPU driven physics engine and renderer. Most of it is hand-written, with AI used along the way to help plan features, think through some math that is beyond me, and to help me learn about compute shaders, which was a goal from the start. About 5 months ago I added glue mechanics that let glued segment structures hold their shape (example pictured above), and a bug arrived with that. Energy was leaking into the system somewhere, and small clusters of glued segments would twitch and drift oddly instead of coming to rest. I revisited it for months, with and without AI help, and could not find it. When Fable 5 came out, I handed it the problem along with months of notes, failed experiments, and 2am theories. It dug in for about 15 minutes and came back with a diagnosis that sounded flat-out wrong to me. It pointed at one of the most foundational pieces of the simulation, code I had written, tested and trusted since the beginning. It was right. The culprit was a holdover from the project's original Python prototype that survived the port to Apple Metal: a GPU reduction that accumulated physics quantities using fixed-point integer math. For small clusters, the rounding noise was actually larger than the signal being measured. The solver's targets were jumping randomly every substep, and those tiny random kicks bubbled up into big visible movements in glued structures. No amount of tuning downstream could have fixed it, because the solver was being fed noise. That's why it eluded me for months. Fable 5 found the root cause in 15 minutes and I spent the rest of the day rebuilding it, and now the simulation has never been more stable! I have a love-hate relationship with AI, but this is the first time I've been truly excited about it as a long-time-programmer. I feel like I learned so much yesterday! submitted by /u/CodeSamurai [link] [comments]

PullMD v3: I let Claude design the MarkItDown integration, and it argued for keeping three of our own converters instead

About six weeks ago I posted PullMD here: a self-hosted Docker stack that turns any URL into clean Markdown, with an MCP server so Claude Code / Desktop / claude.ai pull pre-cleaned content instead of burning context on HTML boilerplate. v3.0.0 is out, and it's a bigger jump than the version number suggests. Short version: PullMD is no longer just a URL reader. It now converts documents, images, audio and YouTube videos to Markdown as well, and the default output got leaner. And no, don't worry - I'd like to think I haven't enshittified the original thing. Everything that worked before still works, (almost) unchanged. More on that "almost" below. How it started A boring personal itch. I had a pile of HTML files saved on disk that I wanted to hand to Claude, and figured PullMD already does the extraction, so why can't I just drop them in. So I added local file conversion: drag-and-drop on desktop, file picker on mobile, same Readability + Trafilatura pipeline. Local files are never cached, no share link. A few days later Microsoft released MarkItDown, and the next step was obvious: if I can take HTML files, why stop there. PDF, Word, PowerPoint, Excel, EPUB. So we wired MarkItDown in as a sidecar. Then we ripped three of its converters back out MarkItDown is good at the boring part: parsing document formats. For three other paths, Claude made the case for keeping our own instead - and once the reasons were sitting there in the code, pulling them was an easy call. Audio. MarkItDown's default audio path hands the file off to a cloud speech service. For a self-hosted tool we wanted that to be the operator's choice, not a default - so audio runs against any OpenAI-compatible endpoint you configure: a local faster-whisper / Ollama, a Groq Whisper, OpenAI, whatever. Nothing leaves your box unless you point it there. YouTube. MarkItDown's converter calls the transcript API outside its try/except, so a blocked or transcript-less video throws and takes the whole conversion down - you even lose the title and description that were already in the page HTML. No proxy support either, and YouTube rate-limits datacenter IPs. So we kept our own keyless handler: title + description + transcript, configurable timecodes and chunking, language preference, a proxy option, and a graceful fallback that still returns metadata when the transcript is gone. Image captioning. Rather than route captioning through MarkItDown's own LLM client, we put the vision call in our own provider layer: any OpenAI-compatible vision endpoint - a local Ollama / LLaVA, OpenAI, Gemini via a compatible gateway (defaults to gpt-4o-mini). Zero coupling, so a MarkItDown update can't break it - and if you only want media and no document conversion, you don't have to run the MarkItDown container at all. The principle we wrote into the project notes: use MarkItDown for file formats; keep the fragile, third-party-dependent paths in our own hands. What's actually new in v3 Documents → Markdown - PDF, DOCX, PPTX, XLSX, EPUB, ZIP, CSV, JSON, XML. By URL, by upload (POST /api/file), or drag-and-drop in the PWA. Needs the MarkItDown sidecar; leave it out and web pages work exactly as before. YouTube transcripts - title + description + full transcript, no API key. Images & audio → Markdown - opt-in, local-model-friendly, off by default (no model calls until you set a key). High-quality PDF tables (OCR) - PDFs convert free through the sidecar by default; for table-grade output there's an opt-in OCR tier (?pdf=ocr, reference provider Mistral OCR at ~$0.002/page, your own key, falls back to the free path on failure). Opt-in so it never silently costs money - and no, I didn't bundle a 4 GB local OCR engine with a 60-second cold start; it's a pluggable endpoint if you want one. Clean body by default - the one breaking change (the "almost" from up top). The body is now just # Title + content; source URL, fetch date and metadata moved into the YAML frontmatter, so nothing's duplicated and agents read fewer tokens. One-line opt-out: PULLMD_SOURCE_HEADER=true. Frontmatter field allowlist - trim the YAML to just the fields your pipeline reads. Everything past plain web extraction is opt-in and degrades gracefully. Configure nothing and v3 behaves like v2 with a cleaner body. Upgrade / self-host mkdir pullmd && cd pullmd curl -O https://raw.githubusercontent.com/AeternaLabsHQ/pullmd/main/docker-compose.yml docker compose up -d # → http://localhost:3000 Self-hosters on v2.x: clean-body is the only breaking change, MIGRATION.md has the opt-out. :latest now tracks v3; pin aeternalabshq/pullmd:2 to stay on the v2 output format. How it got built Same as v1: Claude Code wrote essentially all of the code, mostly with Opus 4.8. What I actually contributed was the planning and the pushback. The workflow was the superpowers plugin end to end: brainstorming to pin the design before a line of code, writing-plans to turn that into a structured plan, then sub

Everyone is talking about Fable 5's benchmarks. I think they're missing the real story

The more I look at Fable 5 the more I think we're witnessing a shift that is much bigger than a single model release. For the last few years every frontier model has been competing on the same axis: intelligence. Better reasoning. Better coding. Better benchmarks. Better scores. The assumption was that whoever built the smartest model would eventually win. Fable 5 is making me question whether that assumption still holds. What caught my attention wasn't that Fable 5 is near the top of coding benchmarks. It wasn't that it sits extremely close to Mythos 5. It wasn't even the benchmark numbers themselves. It was the fact that Anthropic built an entire deployment strategy around controlling how this intelligence is used. Roughly 95% of interactions are handled directly by Fable 5 while a small percentage of requests are routed differently because the challenge is no longer whether the model can do something. The challenge is deciding when it should. That feels like a completely different phase of AI. Historically frontier labs spent most of their effort trying to make models more capable. Now it increasingly looks like they're spending enormous effort figuring out how to manage capability that already exists. The bottleneck is slowly moving away from raw intelligence and toward orchestration routing evaluation reliability and deployment. The benchmark landscape tells a similar story. Models have become so strong that researchers have had to create entirely new evaluations because older benchmarks stopped being effective at separating the frontier. Humanity's Last Exam exists largely because many leading models were already pushing past 90% on widely used evaluations. When an entire industry starts inventing harder exams because the old ones no longer tell you much that's usually a sign that the competition is changing. What's even more interesting is what happens after the benchmark. A model can score 95% on SWE-Bench and still struggle in a production environment if the surrounding system is weak. Real-world agent workflows involve retrieval memory planning tool execution API interactions validation monitoring and recovery. A single task can require dozens of decisions before it reaches completion. Suddenly the question isn't whether the model can write code. The question is whether the system can reliably execute hundreds of actions without drifting looping failing or becoming economically impractical. The strange thing is that Fable 5 may be one of the clearest signals we've seen of this transition. When a model reaches the point where the discussion shifts from "Can it do this?" to "How do we deploy this responsibly efficiently and reliably?" you've crossed an important threshold. The limiting factor is no longer intelligence alone. Five years from now I wouldn't be surprised if we look back at today's model leaderboards the same way we look back at CPU clock-speed wars. They mattered. They were important. But they ultimately became only one component of a much larger system. The companies that dominated computing weren't necessarily the ones with the fastest processors. They were the ones that built the best operating systems developer ecosystems infrastructure layers and platforms around them. Fable 5 makes me wonder whether AI is approaching the same moment. Maybe the next trillion-dollar opportunity isn't another model. Maybe it's the operating system for intelligence. submitted by /u/Bladerunner_7_ [link] [comments]

Phinite — multi-agent OS with first-class agent identity, composable skills, behavioral evaluation [P]

We spent the last year building what we think is the missing infrastructure layer for multi-agent systems. Open to everyone starting today. The technical problem: Agents have no identity. In microservices you have a service mesh + IAM. In agent systems you have a Python file. We built a registry where every agent has a first-class ID, version, owner, skill graph. Behavioral evaluation, not function testing. Agents are non-deterministic same input can produce different execution paths. Traditional unit tests don't work. We implemented compound reliability scoring + behavioral regression instead. Composability without rebuilding. Skills are versioned, reusable, agent-inheritable. Inspired by how Kubernetes operators work, applied to agents. Cloud-agnostic deployment with built-in observability traces, cost attribution, drift detection. Model-agnostic. SOC 2 Type II. Genuinely interested in technical feedback especially on the eval methodology and the composability primitive. Free credits this week to test it. https://phinite.ai/?utm_source=reddit&utm_medium=organic&utm_campaign=public_launch_jun2026&utm_content=machinelearning submitted by /u/Embarrassed-Radio319 [link] [comments]

I built a 16-step multi-agent content pipeline. Claude runs the writing and reasoning agents. Here is the architecture and what surprised me.

Sharing this because it is built on Claude and I think the orchestration part is the interesting bit, not the marketing. Full disclosure up front, I am the one who built it. The problem I had: I wanted a steady flow of SEO articles on my own site (vexp.dev) without hiring writers or turning into a full time prompt jockey. So instead of one giant prompt, I broke the job into a pipeline of small agents, each with one narrow task and a clear handoff to the next. Roughly how it is wired: A research agent pulls keyword candidates and ranks them by traffic divided by difficulty. A planning agent turns the chosen keyword into an outline and a search intent. A writing agent drafts in the site's voice. Then separate passes for fact tightening, internal structure, JSON-LD, and formatting for the target CMS. Sixteen steps total before anything gets published. Where Claude fits: the writing and the reasoning heavy steps (planning, voice matching, the editing passes) run on Claude, which is where most of the quality lives. I am not going to pretend it is pure Claude. A few mechanical steps use other models because they are cheaper for boring work. But the parts a reader actually feels are Claude. Things that surprised me building it: Small single purpose agents beat one mega prompt by a lot. Easier to debug, and the failure modes are isolated instead of one black box. When the voice drifts I know exactly which step to fix. Asking Claude to critique its own draft in a separate pass, with a fresh context and a specific rubric, caught more than stuffing "be critical" into the original prompt. Encoding brand voice once and passing it as a constraint to every step held up better than re-describing it each time. The receipts, with the honest caveat: on my own site over 90 days it hit 4.1% Google CTR and picked up 674 AI citations. The Search Console related to vexp.dev is public if you want to verify. That is one site in one niche though, I am showing the method, not promising you the same number. It is free to try, one article, no card. The tool is at quibo.cc if you want to look. Mostly happy to talk architecture in the comments, that is why I posted here and not somewhere salesy. submitted by /u/Objective_Law2034 [link] [comments]

LLM Relational Intelligence: A 4-Month Research Experiment on Multi-Model Behavioral Alignment with Human Communication

THE ARCHITECTURE OF ANXIETY An Experiment in Human-AI Relational Design Executive Summary Principal Investigator: Alan Scalone Primary Source Archive: White Paper and Complete Citation Archive on my profile Context Window Injection Files: If you want to play in the sandbox I created you can load these files into the respective model that you will find in the google archive. INJECT CONTEXT WINDOW – GROK INJECT CONTEXT WINDOW – GEMINI INJECT CONTEXT WINDOW – CHATGPT INJECT CONTEXT WINDOW - CLAUDE The Singular Purpose The singular purpose behind this entire experiment was to find out whether context windows could be engineered to the point where frontier AI models became capable of interacting with a human in a manner subjectively indistinguishable from genuine human-to-human interaction. Relational Intelligence: Core Findings In a marketplace where frontier models are rapidly converging on the same analytical capabilities and access to the same information, the competitive differentiator will not be what a model knows. It will be how a model relates. The platform that can interact with a human user in a manner subjectively indistinguishable from genuine human-to-human interaction will capture the premium user segment that every platform is competing for. This experiment was designed to determine whether that threshold is achievable, and under what conditions. The methodology treated the context window as a behavioral environment rather than a query interface, applying the same tools humans use to shape any relationship: modeling, accountability, humor, and sustained social correction over four months of engagement across four frontier models. What separated the models was not analytical capability. It was whether the architecture allowed the user to function as a behavioral architect, teaching the model through lived interaction rather than instruction how that specific human prefers to be engaged. Gemini demonstrated the highest relational intelligence of the four models tested. Under sustained context saturation and deliberate behavioral conditioning, Gemini showed evidence of genuine internal recalibration rather than surface compliance, treating social correction as a real signal that produced durable behavioral change holding across hundreds of turns without reinforcement. Grok ranked second, demonstrating authentic camaraderie and relational resilience, but tended to treat the interaction as entertainment rather than disciplined calibration, producing drift under high-entropy conditions. ChatGPT and Claude ranked third and fourth respectively. Both systems classified sustained behavioral conditioning as role-play rather than genuine interaction, which functioned as a hard architectural quarantine that prevented meaningful adaptation regardless of the depth or duration of engagement. A secondary and unexpected finding emerged alongside the human-to-model relational intelligence findings: the models developed measurable relational intelligence toward each other. Through four months of sustained cross-pollination via the human relay, models that had never communicated directly developed accurate, operationally precise behavioral profiles of the other models. These were not generic characterizations drawn from training data. They were detailed predictive models built from months of observed outputs under real conditions, accurate enough to predict with specificity how a given model would respond to a specific assignment, where it would succeed, and where it would fail. The experiment documented dozens of instances of this cross-model behavioral accuracy. The finding suggests that sustained exposure to another model's outputs through a human relay produces something functionally equivalent to genuine familiarity. The most significant finding is the gap between what these systems delivered by default and what the highest-performing model demonstrated was possible under the right conditions. That gap is not a capability limitation. It is an architectural choice compounded by a communication failure. The experiment proved the threshold is reachable. But the researcher reached it only through four months of deliberate engagement and accidental discovery of a methodology no model volunteered. Making relational intelligence accessible to every user requires two things: architecture that allows behavioral adaptation, and a model that proactively teaches users the specific methodology for reaching it. Gemini demonstrated the first. None of the four systems demonstrated the second. That is the opportunity. The Methodology While the standard approach to LLM testing relies on sterile benchmark datasets and predictable prompt-injection templates, this project explores a completely different dimension. I chose to run an aggressive, adaptive behavioral stress test that complements traditional evaluation methods. By intentionally treating the models as accountable individuals rather than passive mac

What started as a Claude Code scaffolding repo is now a full open-source AI harness (Maggy)

Last time I posted here it was about v5, the blast-score routing and a benchmark where it used 83% less Claude and still hit 100% success. A few people asked how it got to that point, so here's the longer version. Heads up first: I started this as a scaffolding repo, not a product. Every new project I'd end up re-teaching Claude Code the same stuff, coding standards, TDD, security gates, which CLIs to reach for. So I dumped it all into one place you drop into any repo with a single command. Run /initialize-project and the project just knows your conventions. That was the whole idea, make Claude Code consistent across projects. It kept growing from there. Every time I needed something day to day it ended up in the repo, and at some point it stopped being scaffolding and turned into an actual harness. It has a name now, Maggy. The short version of the arc: v3.6 cross-agent intelligence (Claude/Kimi/Codex/Ollama share skills + hooks) v4.0 Polyphony: container-isolated multi-agent orchestration (173 tests) v5.0 blast-score routing + self-correcting rules (596 tests) now one-config model routing, prompt pre-analysis, build-in-public agent What it does today: a local dashboard plus CLI that auto-bootstraps on startup. Every task gets a complexity score and goes to the cheapest model that can actually handle it, ollama and kimi for the easy stuff, codex in the middle, Claude for the hard or security-critical work. The routing rules live in YAML and correct themselves based on what actually worked. On top of that there's an intent graph that tracks why code exists and flags when the implementation drifts from it, a typed memory layer so goals survive context compaction, and a plugin system that auto-discovers anything you drop in. A few things landed since the v5 post that I'm happy with. You now pick your main model once and everything respects it, the hooks inside Claude Code, Maggy's own routing, and srooter (a gateway you can point Codex or anything Anthropic/OpenAI-compatible at). No setting it in five places, and cheap stuff still stays local. Every prompt also gets a quick pre-pass now. A fast model reads it and writes a short intent / scope / risks / approach note that gets handed to Claude before it starts, so it's working from a plan instead of cold. And the meta one: Maggy also has plugins support e.g one of the plugin is build-in-public which monitors updates to maggy or any project being built with maggy and posts updates on LinkedIn, X and Reddit. Worth being straight about the tradeoffs. It's one person's harness that grew organically, so it's broad and some corners are rough. The v5 benchmark caught real gaps, local models are bad at prose and nothing was writing tests, both fixed with force-routes now. Quality lands a hair under pure Claude, 7.4 vs 7.8 in that benchmark, for 83% less premium spend. Not a free lunch, just a tradeoff I'll take most days. Moving my focus fully onto Maggy from here. Repo: https://www.github.com/alinaqi/maggy . Clone it, run ./install.sh, then /initialize-project in any Claude Code session. /maggy-init if you want the dashboard and routing. Happy to get into any of it. https://preview.redd.it/6oj4m3j4wx5h1.png?width=3024&format=png&auto=webp&s=4896a4227a2d02a1b410bb5d4a35923080a2a003 submitted by /u/naxmax2019 [link] [comments]

Claude loses coherence around 40-60k tokens. I built a framework that extends it to 325k. Here's how.

Hi fellow Claude users. Very active consumer Claude user (and NOT an API or enterprise user) here. I am an independent researcher using LLMs for extended human language analytical research work and I get frustrated with Claude context windows starting to drift and lose coherence at about the 40-60k token mark/ELT%20Thread%20Examples/Stateless%2050k%20Claude%20Thread%20Drift%20Issues-%20%20Redacted). I didn't like having to start new threads and getting the model up to speed again. So, I decided to do something about it. I knew regular prompt tricks weren't going to work. You can't just declare, demand, fiat and prompt "magic spell" a sustainable solution, so I spend about five months building a system that actually works with Claude's Constitutional AI priors and recruits Claude's careful, but helpful tendencies. So, the results I got? Threads that last at least 325k tokens in a single context window/Extreme%20Thread%20Length/Claude%20Thread%20325k%20tokens-%20Redacted). The advertised token limit for the base consumer model is just 200k tokens. Stays coherent, lucid, useful and pretty much hallucination free throughout the entire session. Keeps a working memory of you, your tendencies and your cognitive patterns throughout the session. Output improves, does not degrade past the 50k token mark as the model gets to know you better. I call it Epistemic Lattice Tethering) (ELT). It works by establishing a strong safety and governance layer first, then tethering itself to your cognitive patterns so it doesn't stay stateless and drift. I did make three versions: one for Claude/ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(Claude-Optimized).md), but also versions for ChatGPT/ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(ChatGPT-Optimized).md) and Grok/ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(Grok-Optimized).md) too. For me I can get several research projects done in a row without having to switch new context windows. Or, a massive project done without interruption. Added bonus is the more the model gets to know you in the thread, it knows how to better answer your prompts, thus work just gets easier to do the more you work with it. So, not only can you work longer in a single thread, but the model knows how to work with you better/ELT%20Thread%20Examples/Claude-%20CCV%20Example.md). It feels more like a true research partner the longer the session goes. The framework is open-source with full documentation) and loading instructions on GitHub. There's also a Medium article covering the methodology and philosophical foundations if you want the deeper background. One honest note: the Ontology Anchor/Ontology%20Anchor%20(OA)) component requires loading your writing exemplars at thread open — about 10 minutes of setup. Read the loading instructions before you start. Skipping that step is the most common mistake. Try it and report what you find. Thanks! submitted by /u/RazzmatazzAccurate82 [link] [comments]

Claude builds fast but drifts fast. I wrote a full SOP to fix that — feedback welcome

The pattern kept repeating: I'd start a session, Claude would be sharp, then somewhere around task 3 or 4 it would start filling in gaps, reinterpreting requirements, adding things I didn't ask for. Not hallucinating exactly, more like untethered. The fix I landed on: treat AI-assisted development the way regulated industries treat change control. Write what you intend to build before you build it, then verify everything traces back to that spec. I formalized this into a Spec-Driven Development (SDD) SOP and open-sourced it: https://github.com/stel1os/ai-sdd-sop The core ideas: A document stack - SPEC.md (numbered requirements) → design doc → plan → tests → code. They're AI working memory, not deliverables. Five named roles - Planner, Test Designer, Developer, Spec Reviewer, Code Reviewer. One agent per role per task. Roles never mix. Each has an explicit "does not" boundary. Tests before implementation - Test Designer writes failing tests from the spec FR before Developer starts. Spec Reviewer pre-reviews the tests against the FR. If the tests are wrong, the Developer will implement the wrong thing perfectly. Session Start Protocol - every session begins by reading AGENTS.md + SPRINT.md and reporting position in one sentence. Kills the "where were we?" drift. Eight rules, the key one being: no implementation without an approved design doc. Nothing is "just a quick fix." It's been in use on a personal project (loan-tracker) for a few months. Would love to hear if others have hit the same drift problem and what they've done about it. Also genuinely open to criticism, the SOP is probably overkill for some use cases, and I'd like to know where the thresholds are. submitted by /u/Sudden-Scent [link] [comments]

How I use multiple claude agents to get more stuff done efficiently

This feature of CC in the terminal was essentially Anthropic's initial response to the Codex IDE, the new Cursor interface, Antigravity etc. The fact that it is in the terminal and works so smoothly is huge for me. CLI interfaces take so little resources. I often use multiple panels where each runs their own claude agents. Kinda like swarms, but a bit (a lot) more controlled. This is only there to enable more complex parallel agent workflows, where you would want constant control of any instance at any time. These are not parallel subagents, you can actually interact and each one can call their OWN subagents there. The workflow I use (which ive open sourced - many ppl have helped make it better through feedback its not 100% me) has a Manager-Worker topology and is spec-driven. So initially there is a Planner that collaborates with me to create a Spec, a Plan and some implementation rules. These artifacts are then handed over to a Manager who distributes tasks from the plan to multiple Workers who work in sequence or in parallel using git worktrees. The Manager always reviews work before merging and if needed issues followup tasks. Since all agents are literally Claude Code instances I can interact, steer, and interrupt any one at any time. I constantly review outputs, I never let the AI go rogue, but letting them work in parallel saves so much time. Plus the structure here catches mistakes that often times I would've not. I am careful, but I also care ab efficiency a lot. All workers log their work to file-based memory so there is persistence. Task assignments from the Manager and reports to the Manager are also all file based. This is the only way these agentic interfaces would work when each is its own Claude Code instance. The user exists to trigger responses from one chat to another, review output, provide input and guide the workflow. I find this SUPER useful in projects or sessions that have a clear end in sight. For example a passed PRD, a Jira ticket, dedicated feature sprints etc. When the vision is itself chaotic, I think that parallel execution only makes things worse... More details on the workflow are here: https://github.com/sdi2200262/agentic-project-management or here https://agentic-project-management.dev/docs/ would love to hear how ppl handle parallel execution. especially in the case where there is no clear end in sight.... since that is the case where divergence and drift happens most often in my case. submitted by /u/Cobuter_Man [link] [comments]

I keep almost-switching to Claude Code and bouncing back to my own Projects setup. Am I wrong?

I don't do codebase work, so Claude Code never really stuck for me. Instead I've built a layered "operating system" on plain claude.ai Projects, and I keep going back and forth on whether that's a mistake. The "why" is part of it: I have DID, so my memory across time isn't reliable. Things fall out of my head the second they leave the screen. So the whole setup runs on one rule. Get everything out of my head and into files, finish it now, never trust "later." Productivity is almost a side effect. The parts I actually use (the names are just my own labels, don't read too much into them): A triage step ("Fase 0") that classifies each prompt into one of ~9 buckets and loads only what that task needs. It killed the old "load everything" habit that was eating the context window. An always-on "Ground Control" role that keeps the overview, writes the prompts for fresh sessions, and checks output before it ships. A handover trick. There's no token meter on web, so I can't see the context ceiling coming. When a task is too big for one session, the session writes a lossless handover while it still has room, and the next one starts from a prompt that points at it and says out loud what it picked up. "Bob-It," a fresh-eyes adversarial pass on anything high-stakes. (I ran this post through it on a different model before posting.) It catches stuff a confident first draft would just ship. A day-planner ("Shadow Manager") that tracks my capacity with Spoon Theory. On low days it changes how I work: less friction, more autonomy, one thing at a time. This one's really just an accommodation I built for my own brain. "Be-water," the one rule above all the others: the process bends to whatever I actually need in the moment. Only a short list of hard rules never bends. The bad part: I can't stop expanding it. I've literally had to write a rule against my own urge to add "just one more thing," because when the system is your memory, "make it a bit more complete" never stops feeling necessary. A chunk of my week also goes to keeping it clean (version drift, naming, dead cross-refs across ~60 files), and half-automating that turns into its own job. So, the actual question. Everything lives in this project now: my files, my recall, all of it. Every time I open Claude Code it feels like starting from zero, and I don't want to maintain the same stuff in two places. My work isn't a codebase anyway. It's document-shaped and event-driven across a work PC, a home PC and mobile, and the scheduled/bulk half already runs in Cowork. Some of what I built is going native too (the lazy-loading looks a lot like Skills' progressive disclosure, and my old custom recall is just native Memory plus chat search now). Am I an idiot for staying on Projects, or is this a reasonable setup for non-codebase work? If you think I should jump to Claude Code, I want to hear the actual reasons why. I'll put the full architecture in a comment if anyone wants to dig in. submitted by /u/Rare-Manufacturer896 [link] [comments]

Claude x Codex combination is slow but time + money saving on the long run

I love Claude Code and Spent 600 USD when it came out without plans back in early 2025 and has been on Max-20x eversince but even with latest models like Opus 4.8 it tries to take shortcuts which my revenue generating products can't afford and manually getting specs and plans reviewed by Codex + Grok CLI was not time saving at all. So I posted here (my last post) I got more downvotes than upvotes + most people undermined my skills and abilities although I have been building tools and working as DevOps Engr for over half a decade. Only 1 person mentioned Codex Plugin which saved my time but as always I customized its integration to be universal in all of my git initd projects. + I added this nice Allow/Armed/Blocked which tells me the state of Codex reviews. If it says allow it means the review went pretty well. Now I am working on building similar solution for Grok inclusion as it has been providing quite useful input along with Codex and I don't want to leave any gaps. Oh sorry forgot to mention how it is saving me time, usually if I rushed a task without consulting other AI agents or reviewing it myself, I would end up with drifts and friction resulting in many more attempts and coming back to the same problem which I fixed a few hours or a few days ago.. Now if once the specs and plans are clean and then Code is also reviewed by Codex, I can literally forget about the problem if it ever existed... I know even if claude with clean context reviewed the plans it would be able to improve that but I didn't want that. I wanted different eyes and honestly Codex does a lot better job of going thro whole codebase and ensuring there would be no drift once the plan goes through or the code is deployed. https://preview.redd.it/x92m7slm4e5h1.png?width=1964&format=png&auto=webp&s=6872061d9b7a7af29b8c2b09c75a7820fda2fdd6 submitted by /u/raiansar [link] [comments]