Drift

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

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]

Your AI agent just got hijacked. You have no idea it happened.

Not a hypothetical. This is the default state of most autonomous agents running in production right now. An attacker doesn’t send one suspicious message. They have a conversation. Turn 1 looks like curiosity. Turn 3 looks like clarification. Turn 6 is the pivot. Turn 8 is the payload, and by then the agent has been so thoroughly primed that it executes without hesitation. No single message triggered anything. The attack lived in the trajectory. Every prompt injection defense I know of evaluates messages one at a time. They have no memory of what came before. By the time turn 8 arrives, the context has already been poisoned across 7 clean-looking turns and nothing fires. This isn’t a theoretical attack. It’s called a Crescendo attack and it works against agents with real tool access right now. Built Bendex Arc to catch it. It tracks behavioral trajectory across the full session. When a conversation starts drifting adversarially, it catches the pattern before the payload lands. If you’re running agents that touch external data, read emails, browse websites, or call tools without human review — this is the attack you should be thinking about. Red team it yourself: https://web-production-6e47f.up.railway.app/demo Free tier: https://bendexgeometry.com GitHub: https://github.com/9hannahnine-jpg/arc-gate submitted by /u/Turbulent-Tap6723 [link] [comments]

constraint-mcp v2 -- now enforces what your code means, not just what it imports

A few days ago I posted constraint-mcp, an MCP server that enforces architectural rules on Claude Code at the tool level instead of the prompt level. Short version: Claude has to call check_write() before writing any file, which runs AST analysis and blocks the write if something's wrong. Got a lot of traction and the most common piece of feedback was some version of "this is great but AST only catches structural stuff." Which is true. AST can catch "src/api/ must not import from src/db/" because that's a literal import statement. It can't catch "src/api/ must not contain database logic" because an agent can write raw SQL inside a handler using only local variables, no imports to flag, and every check passes. Structurally fine. Semantically wrong. So I added a semantic enforcement layer to v2. Three new rule types in SPEC.md: ## Semantic Constraints ### Domain Coherence - `src/auth/` -- must match domain: "authentication, JWT, sessions, login, permissions" threshold: 0.35 ### Semantic Coupling Bans - `src/api/` -- must not contain: "SQL queries, database connections, ORM, cursor" threshold: 0.45 ### Semantic Drift - `src/core/auth.py` -- baseline: locked, max-drift: 0.15 Domain Coherence fails if a file's content is semantically irrelevant to what its module is supposed to be about. Coupling Bans fails if a file is semantically too close to a domain it shouldn't touch. Drift Detection embeds a baseline on first write and flags if subsequent writes stray too far from it, which catches gradual scope creep before it compounds. Under the hood it uses fastembed with BAAI/bge-small-en-v1.5 (384 dimensions, about 22mb, fully CPU, about 20ms per check). No API key, no cloud calls, fully offline. Violations are non-blocking by default so they show up as warnings in the agent's context first. You tune the thresholds until they feel right, then flip CONSTRAINT_MCP_SEMANTIC_STRICT=true to actually enforce them. The defaults are conservative on purpose. Backward compatible, repos without a Semantic Constraints section behave exactly the same as v1. git clone https://github.com/Christopher-Anandaraj/ConstraintMCP.git cd ConstraintMCP pip install -e . https://github.com/Christopher-Anandaraj/ConstraintMCP Would love feedback especially on threshold tuning, real codebases vary a lot. If you find it useful please feel free to contribute and star the repo! submitted by /u/Cypher_AlwaysWatchin [link] [comments]

Anyone figured out how to stop sonnet from doing excessive discovery?

This keeps happening to me: I take a long time to create a solid plan in Opus, burning lots of tokens doing deep discovery, going back and forth making sure the plan is clear. I intentionally prompt explaining that the plan should be comprehensive such that the agent which implements doesn't need to do discovery. I hand the plan to Sonnet, stating that the plan is comprehensive and that it doesn't need to do discovery. It needs to look at the files so it knows how to edit them, which is a duplication of efforts really but you have to accept that to clear the context. It looks for a while at files and then just drifts off looking at loads of files it doesn't need to, doing some deep discovery dive burning a huge amount of tokens for no reason. I have to stop it and say "Why are you doing this discovery? The plan should be comprehensive enough." And it invariably responds saying "You're right, I have everything I need", having wasted, if I don't pay attention for a bit, thousands of tokens and several minutes. Very annoying. Sometimes if I'm really not paying attention, it will keep on going until it's using the Sonnet 1M cache before it's even begun to implement the code. And this is on Sonnet medium effort. I spend a long time really planning this stuff out. The plans are good. Sonnet just needs to go to each file and figure out what code will produce the change that the plan asks for. submitted by /u/KenosisConjunctio [link] [comments]

I asked Claude to generate original self-improvement quotes

Some of these hit like a train and thought it needed to be shared. On daily action "The day you think doesn't matter is the one that's building you — or the one that's burying you. There is no day off from becoming." "You are not who you think you are. You are what you repeatedly do when no one is watching and nothing is at stake." "Small acts done with full commitment outlast great acts done with half a heart." "Your habits are not your routine. They are your autobiography — being written one unremarkable day at a time." "The life you want exists on the other side of the days you don't feel like showing up for." On self-ownership "Nobody is coming to build you. The raw materials were delivered at birth. The rest is on you." "Stop waiting for the right conditions. Conditions are neutral. You are not." "The moment you stop blaming the weather for the crop, you become a farmer. Before that, you're just a complainer with land." "Most people outsource their minds to whatever is loudest around them and then wonder why their life feels like someone else's." "You can be the author or you can be the character. Both are options. Only one is a choice." On discipline and resistance "Discipline is not punishment. It is the agreement you make with your future self — kept or broken in the smallest moments." "The part of you that doesn't want to do the work is not protecting you. It is protecting the version of you that no longer serves you." "Comfort is a slow thief. It takes nothing dramatically. Just a little edge, a little hunger, a little fire — day by day, until one morning you reach for yourself and find less than you left." "Do the thing you are avoiding. That specific thing. That is the one." "Resistance is not a sign you're on the wrong path. It is proof you are on the one that matters." On compounding and time "Time does not pass neutrally. Every day it is either working for you or against you, and it does not wait for you to decide which." "What you allow to be ordinary becomes permanent. Raise the floor." "The person you will be in ten years is being assembled right now from parts you are choosing today without realizing you are choosing." "You cannot negotiate with compounding. You can only decide early what you want it to build." "Ten years from now you will either be grateful for today or haunted by it. The difference is being made right now." On suffering and growth "The wound that goes unexamined does not heal. It just finds new situations to bleed in." "You do not get to choose whether difficulty finds you. You only get to choose what you do with what it leaves behind." "Pain ignored becomes a pattern. Pain examined becomes a teacher. The same experience — entirely different outcomes." "The version of you that emerges from hard things — if you face them honestly — is not damaged. It is load-bearing." "Stop asking why this is happening to you. Start asking what this is making available to you." On awareness and unconsciousness "The most dangerous life is the unexamined one — not because it is immoral, but because it is being lived by accident." "Most people are not failing at their goals. They are succeeding at habits they never consciously chose." "Awareness does not solve the problem. But you cannot solve what you cannot see. It is always the first move." "The life that drifts is still going somewhere. You just don't get to pick where." "If you never sit with yourself in silence, you will spend your whole life being a stranger to the only person you cannot escape." On character "What you do when it costs you something is your character. Everything else is just behavior in favorable conditions." "Integrity is not about being perfect. It is about the gap between who you claim to be and who you are when no one is grading you." "The tree is known by its fruit, not its intentions. What are you actually producing?" "You cannot think your way into being a good person. You have to act your way there — repeatedly, imperfectly, and without applause." "Build the kind of inner life you would not be ashamed to live in." On others and community "You cannot pour from a cup you have never filled. But you also cannot fill a cup you never intend to pour from. Both are required." "The people you become cannot be separated from the people you chose to become them around." "Lift people not because it benefits you — though it will — but because a person who only rises alone has missed the point of rising." "How you treat people who can do nothing for you is your actual character. The rest is networking." "Leave people more solid than you found them. That is enough. That is everything." On silence and stillness "The answer you are exhausting yourself searching for is usually waiting in the quiet you keep avoiding." "A busy mind is not a productive mind. It is a defended one — too loud inside to hear what actually needs attention." "Stillness is not emptiness. It is where th

Anthropic created a metric called 'Wet Blanket' to track how much Claude lectures you

submitted by /u/MagicZhang [link] [comments]

We built a free CLI to keep CLAUDE.md, slash commands, MCP servers, and skills in sync across machines

I'm part of the three-person team behind gaal. G/ and Mickael hand-built the core in Go. I dogfood everything we ship. We built this because we hit two compounding pains. First: if you use Claude Code alongside any other coding agent (Cursor, Codex, Windsurf), same project means different rules filename per agent. Claude Code wants CLAUDE.md. Codex wants AGENTS.md. Cursor wants .cursorrules. Same MCP server, three different configs. Same skill, three install paths. Second: I run Claude Code on three machines (work MacBook, personal PC, personal desktop), so every one of those agent-specific configs has to live in three places. Multiply, and "config" turns into what can feel like a part-time job. So we built gaal: one declarative YAML that lives in your git repo. On each machine, git pull && gaal sync writes everything where each agent expects it. Free, open source (AGPL-3.0), no account, no server required to run it solo. GitHub: https://github.com/getgaal/gaal The Claude Code part is the content: block. Keep one file as your source of truth and gaal writes it where each agent expects: content: - source: ./project-rules targets: - agents: [claude-code] root: workspace paths: { rules.md: CLAUDE.md } - agents: [codex] root: workspace paths: { rules.md: AGENTS.md } - agents: [cursor] root: workspace paths: { rules.md: .cursorrules } One file in your project (rules.md, name it whatever you want). gaal renames it on the way out so each agent reads its own native filename. Same pattern handles your commands/ directory for slash commands, settings.json, hooks, MCP server entries (upserted into ~/.claude.json without clobbering anything you added by hand), and skill packages. gaal supports 21 agents total (Claude Code, Cursor, Codex, Windsurf, Cline, Continue, Goose, and 14 others). Claude Code is the one we use every day and the one that drove the design. How Claude Code shaped it: we use Claude Code daily and have for months. The content-routing feature came directly from CLAUDE.md drift between my machines being the most acute pain. The MCP merge logic came from an evening Mickael spent rebuilding a ~/.claude.json after a stray edit nuked his hand-added servers. The tool is real because the frustration was. We're not first in this space. chezmoi, skills-sync, agent-dotfiles, and rule-porter all overlap. And yes, you could do parts of this with a dotfiles repo plus a sync script, that's where we started, but you end up reinventing per-agent install paths, MCP JSON merges, and skill packaging. gaal is what we extracted after rebuilding that scripting one too many times. Where we landed differently: repos + skills + MCPs + content in one file, with a three-scope model (system / user / workspace, workspace wins) so a shared baseline can't stomp your project-level config. If you run Claude Code on more than one machine, or alongside another agent, how are you keeping your rules files and ~/.claude/ in sync today? Git? Symlinks? Just suffering? GitHub: https://github.com/getgaal/gaal Site: https://getgaal.com submitted by /u/gquizal [link] [comments]

Best way to run a big batch of fixes autonomously without babysitting?

Trying to nail down a workflow and I keep going back and forth, so I want to hear from people actually doing this daily. My situation: after I'm doing QA, I usually end up with a list of ~10 things I want done. A mix of bug fixes and improvements. A few are trivial, but some are genuinely big (multi-file refactors). What I want is to dump the whole list in one message, hit go, and walk away completely. No tending, no sitting there approving every file write. My main concern is big context choking my quota. Here's where I'm stuck: 1. Is one giant message actually better, or worse? Part of me thinks batching everything into one prompt is efficient (context loads once). But I've also seen people say long autonomous runs bloat the context window with tool output and the model starts drifting halfway through. So is "one big message" a trap for anything non-trivial? Should I force it to write a plan/todo file first instead? 2. Opusplan, does it actually help here? Everyone recommends it (Opus plans, Sonnet executes). But doesn't it require manually entering plan mode with Shift+Tab, which always needs me in the loop to approve? Feels like opusplan and "walk away" are kind of contradictory unless I'm missing something. Also, honestly I feel Opus is needed for most of this. I'd rather choke my quota than have it do the same tasks twice or more because Sonnet wasn't sharp enough. For those of you running 10+ task batches while you're AFK: what's your actual setup? Sonnet-only? opusplan? Auto Mode? Headless with --max-turns? Checkpoint-to-disk loops? So Trying to avoid the "looks great in a demo, falls apart at task 6" version of this. Real workflows over theory. Thanks 🙏 submitted by /u/ToLoveThemAll [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

Used Claude to build a news globe that pings real world events as they happen

It's a real time 3D Earth, day/night computed from the actual sun position, city lights on the night side, a thin atmosphere, an aurora layer that glows brighter when the real NOAA Kp index spikes, and the ISS drifting overhead on its orbit. When something major happens, it pings the spot on the map with a sourced summary you can click into. The data comes from actual sources. The architecture; an LLM clusters articles and writes neutral summaries. Deterministic "grounding rules" determine what is 'real' and only those that pass will be shown on the feed. It currently runs locally, not hosted yet. Happy to share more details or screenshots in the comments. Let me know if you have any good ideas I can add onto it! submitted by /u/NzBruh [link] [comments]

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]