Drift

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

Drift AI

A dead-simple way to catch when your agent starts ignoring your instructions mid-session

Running long agent sessions, I kept hitting the thing where it silently stops following my rules partway through, usually as context fills up. Hard to notice until it's already off the rails. A teammate's trick: add a rule that the agent must open every reply by addressing you by name. Trivial to follow when it's actually paying attention. The moment it stops doing that, it's a signal it's dropping your other instructions too. Canary in a mine: when the bird goes quiet, something's wrong. Cheap to add, and you can grep the logs for it. Been a surprisingly reliable early warning that the session is degrading and I should reset context. Anyone else run a canary/tripwire like this? What other cheap signals do you watch for instruction-drift? submitted by /u/FlakyBite7417 [link] [comments]

How do you keep prompts sane once more than 2 people are touching them?

Genuinely asking, because we hit a wall on this. When it was just me and one other engineer, prompts were fine. We knew what was where. Then the team grew, our PM started having opinions about the wording of the product's responses (fair, that's literally her job), and suddenly every tiny copy change to a prompt was a ticket routed to an engineer who had actual features to build. So the prompts became this weird bottleneck. The person who knew exactly what the output should say couldn't touch it, and the person who could touch it didn't care about the phrasing. We tried a shared doc as the source of truth and within two weeks it had drifted from what was actually running. Nobody trusted it. What sort of worked was letting the non-engineers edit the prompts directly, in a place that kept a version history, so a bad edit could be rolled back and you could always see who changed what. Our PM edits the wording now without pinging anyone, and the engineers stopped being a copy-editing help desk. It only covers the prompt and output layer though, not the retrieval or vector step, so it isn't a whole-pipeline fix. I don't think we've fully solved it though. How does everyone else handle prompts once a whole team is in there, especially the non-technical people who own the voice but can't push code? submitted by /u/Bigabdo03 [link] [comments]

Spent 3 weeks trying to get Claude to click a real mouse on a real monitor instead of a VM — here's what actually broke

Built this specifically as an MCP server for Claude (Desktop/Code/Cursor) — free to try, paid tier exists for heavier use. Every "computer use" setup I found assumes a VM or screen-share software. I wanted Claude to control an actual physical machine — no install, no admin rights, works on locked-down laptops. So I spent the last 3 weeks building this with a phone: camera watches the monitor, Bluetooth HID acts as a real mouse/keyboard, Claude drives it over MCP tool calls (take_screenshot, click, type_text, etc.). Here's what actually broke along the way, in order: First attempt: no perspective correction. Phone propped at an angle, camera saw a trapezoid, Claude's coordinates were consistently wrong toward the edges. Fixed with a 4-point corner calibration (drag corners onto monitor edges once) + perspective warp before every screenshot. Second problem: image resize. Sent full-res camera JPEGs to Claude via OpenRouter — it silently downscales large images before the model sees them, so Claude was clicking based on a blurrier image than I thought. Fixed by resizing to a fixed width server-side before it ever reaches the model. Third: click drift. Bluetooth HID absolute coordinates (0–32767 range) didn't map 1:1 to the warped image without a normalization step — clicks landed a few px off near the edges of the screen, invisible in the center, obvious near corners. Still not solved: camera autofocus hunting under change in monitor brightness (bright dialog popup = brief refocus = one bad frame). One side benefit of physical HID over a virtual input driver: it works on machines where software-based remote control is blocked or unavailable — locked-down corporate laptops, machines without RDP/VNC, anything with just a Bluetooth radio. Net result: reliable enough now for real MCP tool calls in Claude Desktop/Code/Cursor, screenshots below of the calibration flow. No video yet, that's next. Curious if anyone here has fought similar coordinate-drift problems with vision-based computer-use agents — what actually fixed it for you? submitted by /u/Substantial_Tour725 [link] [comments]

How can I turn Claude into a strict accountability partner instead of just a chatbot?

I've realized that my biggest problem isn't a lack of ideas it's consistency and discipline. Whenever I think about working on my career, building projects, or improving myself, I somehow end up procrastinating. I have already wasted several months, and I don't want to keep repeating the same cycle. Wondering if it's possible to configure Claude so it behaves more like a strict reporting manager or accountability coach rather than a friendly assistant. Here's what I'm looking for: # Ask me every day what my goals are. # Take a daily report of what I actually accomplished. # Question me if I didn't complete what I promised. # Ask follow-up questions instead of accepting vague answers. # Help me break down my projects into clear action plans. # Remember the context of my long-term goals. # Push me to stay focused instead of letting me drift into procrastination. # Be supportive when I genuinely need help, but strict when I'm making excuses. For example, one of my current goals is building my Discord server. I'd like Claude to ask things like: # What did you work on today? # How many hours did you spend? # What specific tasks are finished? # What's blocking you? # What's your plan for tomorrow? # Why wasn't yesterday's goal completed? I don't want it to simply agree with me or say "it's okay." I want it to challenge my excuses and hold me accountable while still helping me solve problems and create better strategies. Has anyone successfully built a prompt or system like this? Do you have a prompt, workflow, or project setup that turns Claude into a genuinely strict accountability partner? I'd really appreciate any advice or examples. Thanks! submitted by /u/kamal_dot_one_ai [link] [comments]

XML Prompting System that actually improves claude code's results

Been using claude code daily for months and the thing nobody wants to hear is this: the quality of what the agent hands back has almost nothing to do with the model and almost everything to do with how you set up the task. Swapping to a smarter model moves the needle a little. Framing the task well moves it a lot. And no, I don't mean "prompt engineering" in the guru sense. Magic words, "act as a 10x engineer", that whole circus. I mean the boring structural part nobody wants to do. Telling the agent what NOT to touch. Pointing it at the actual file instead of making it go hunt for it. Writing down the decision you already made so it doesn't relitigate it. That stuff. It's tedious and honestly that's exactly why it works, because almost nobody does it. Here's the failure mode I kept hitting. You type the request in one line, "add rate limiting to the login endpoint", and it feels like enough. But when you write it that short you're leaving everything you already know stuck in your own head. Which file it lives in. The decision you made last week to use a sliding window. That the frontend is off limits. The agent knows none of that, so it fills the gaps, and an LLM filling gaps is just guessing with confidence. A one-liner is basically a memo to someone who can't ask you a follow-up. Think about handing that single line to a new contractor who has no way to Slack you back. What do they do? They guess. Same thing here, except the agent guesses instantly and starts writing code on top of the guess before you can stop it. The other half of this is long sessions. You know how it goes... you start on task A, drift into task B, squash a bug, change your mind about something, keep going. 40 messages deep and the agent is dragging around half-dead context from 3 tasks ago. It half-remembers a decision you already reverted. It's still "aware" of a file you stopped caring about an hour back. And you don't see the drift while it's happening. You see it when the diff comes back wrong and you sit there going wait, why did it touch that. So the fix I landed on is 2 things, and they're kind of dumb in how simple they are. One, build a single dense, self-contained XML prompt for the task. Two, paste it into a brand new session with zero history. XML not because the tags are magic. They're not, plain markdown works fine too. The tags are a checklist you can't skip. An empty tag just sits there staring at you until you fill it in, where a blank paragraph lets you wander right past it. That's the actual trick. The format drags the questions out of you that you'd otherwise skip. Here's roughly what one looks like for that rate-limit task: Senior engineer on a FastAPI + Postgres backend. Work on your own, but never claim anything you haven't checked in the code. Missing info? Say so. Don't paper over it with a guess. Add per-IP rate limiting to POST /api/login: 5 attempts per 60s, then 429. The /login handler and its throttle middleware Don't touch other endpoints, the DB schema, or the frontend Redis is already wired at app.state.redis. We picked a sliding window over a token bucket last week. That's settled, don't reopen it. auth/login.py:42 - the handler to guard middleware/throttle.py:18 - copy this limiter, don't reinvent it - The 6th request inside 60s returns 429 - The existing login tests still pass pytest tests/auth -q That's the actual shape of it. Nothing clever, just everything the agent needs sitting in one place instead of scattered across your head and 40 old messages. Quick pass on why each tag earns its spot, because none of it is arbitrary. The mission is one sentence, one outcome, and that constraint is doing real work. If your mission won't fit in a sentence, that's not one task, it's 2, and you should split it. Vague mission, vague diff, every time. Scope, and specifically the tag, is the one everybody skips and the one that matters most. "Don't touch the DB schema or the frontend." Leave it off and the agent decides on its own how far to reach, and it reaches FAR. That one line is the difference between a 30-line diff and a 400-line one where it "helpfully" refactored half your auth module because it figured it was improving things while it was in there. Code anchors are the big one against hallucination. "The relevant file" makes the agent go look, and looking means guessing, and now and then it lands on a file that sounds right and just isn't. auth/login.py:42 gives it nowhere to wander. Same with handing it a pattern to copy... "reuse the limiter in middleware/throttle.py:18" beats "write a rate limiter", because now it's matching your existing code instead of inventing some new style you'll want to rip out later. Success criteria plus the verify command is the part people sleep on. When you give the agent an actual command to run, pytest tests/auth -q, it checks its own work. It'll catch and fix maybe half its own mistakes before you ever lay eyes

The AI workflows that changed the way I work didn't come from an AI strategy. What worked for you?

I've been thinking a lot about AI adoption over the last couple of years, especially in large orgs. Partly because I've been experimenting with it every day, and partly because I had the opportunity to help hundreds of AWS field employees and customers incorporate AI into their daily workflows. Seeing hundreds of people approach the same problem from different angles gave me an interesting perspective, but also quite frankly a bit of a "cultural shock". Every large organization seems to have an AI strategy now. New tools get rolled out, people get trained, governance gets defined... all perfectly sensible things to do, but when I look back at the AI workflows that have actually changed the way people worked, very few of them seemed to originate from those initiatives. They usually started because someone got annoyed by something. Meeting notes. Customer emails. Weekly reports. The fact that AI would happily forget your writing style every time you opened a new chat. As I kept solving those annoyances myself, I realised I was borrowing more and more ideas from software engineering without really thinking about it. I wanted version control because agents occasionally make a mess. I wanted Pull Requests because I didn't want to blindly accept AI-generated changes. I wanted shared standards because I was tired of copying the same instructions between projects. I wanted scheduled jobs because some tasks simply shouldn't depend on me remembering to run them every Friday afternoon. Looking back, I don't think I was experimenting with AI as much as I was experimenting with whether software engineering already contains many of the building blocks for AI-enabled knowledge work. That got me wondering whether successful AI adoption follows a different path than the "organizationally sensible" one. Maybe leadership creates the conditions, but the transformation itself happens when hundreds of people solve hundreds of small annoyances, share what works, and those ideas gradually become the new way of working. I honestly don't know whether this is just my own architectural bias or whether others are seeing the same pattern. Has anyone else found themselves drifting in this direction? submitted by /u/giusedroid [link] [comments]

I gave Claude Code a content studio (MCP) and it's been running its own product launch

Last week I read about an indie dev who automates his app's marketing and realized I didn't know how to build any of it. So Claude Code and I built the machine itself as an MCP server: broll. What Claude can do through it: generate images/video with my own API keys, compile declarative JSON plans into real ffmpeg renders (captions, music, aspect ratios - deterministic, no prompt drift), render branded carousels where the layout is pure code, and publish to Bluesky/Mastodon (X exports bundles since their API went pay-per-write) - always behind a draft + explicit confirm gate, so nothing posts without me tapping yes. The fun part: it designed its own logo, set its own avatar via the API, published its own launch announcement, and a scheduled task drafts a build-log post from each day's git commits for one-tap approval. Repo (MIT): https://github.com/luke-fairbanks/broll It's early - feedback on the tool surface is genuinely wanted. submitted by /u/bigballer1O1 [link] [comments]

Fable is just ok at coding, I think most are using it wrong.

Fable is just ok at coding, you’re probably using it wrong. But it’s an incredible engineering manager. I’ve been building health related IP for years and finally over the past year decided to do something with it. While formalizing everything I realized I needed to surface this data somewhere (web app or iOS for example). I’m a mid career staff level engineer that’s spent most of my career in or serving big orgs, and frankly, was kinda unsure how to do this with a long term plan in mind so I didn’t have to rebuild a bunch of stuff months or years later. I also need to protect said IP from being exposed. When I started coding I thought ok let’s see what I can do alongside AI. I used Claude to build out a design system while I wrote up a light scope for the tech stack and mild architecture. Opus does a good job of coding so I let it run on the marketing site with little massaging. But for building the first consumer (web app) and middleware/api layer, I fired up fable and fed it my plans, repo structure (it’s not a monolith, so need to access things broadly), and explained it all to it. I asked it to rigorously go through planning with me… and it did amazing. Suggested things I possibly would have done or implemented but I was able to do so with lightning speed and have a bunch of “ah ha” moments really fast. Things it suggested and we built were drift checks on the api so tests fail if something should change on either middleware or consumer in a way that doesn’t sync was really smart. A “moat” for the IP itself. This is what I struggled with and it was very clever in siloing packages and public IDs we could expose in browser without sharing actual backend data. I was able to build the api level in a few days and the app over the last few weeks. A mix of opus and fable. Fable to swarm and test the code then I and copilot to review. This post is long enough so I’ll wrap it up, real long way of saying fable is a monster of a planner. Basically an assistant eng manager. I share a little bit of the scaffold and methodology here: https://github.com/Spotfin/Ballast I’d really love any feedback on it in the scope of IP protected apps/products or how this could be improved? submitted by /u/bmoredrewfoto [link] [comments]

I have better luck with CLI than claude code

I’ve been working on a family of planning applications and have noticed that even with tons of guard rails in place inside foundational documents, specific profile settings and instructions, specific project instructions, etc… that claude code will drift quickly and lately has even fabricated passing test results. Like straight up fabricated results. It got so bad last night that Fable intervened and instructed me to use terminal inputs moving forward. As soon as I made that change, results were faster and my project started moving forward again… To be clear,, I keep conversations short and use roll up docs, decision logs and several other continuity enhancing methods. Has anyone else experienced this and made the change back to using just terminal and relaying outputs back to Claude AI? Thanks in advance. submitted by /u/AdventurousRope9133 [link] [comments]

The counterintuitive part of writing Claude skills: more skills make each one worse

Four patterns that decide whether an Agent Skill actually fires or just sits there installed. The trigger description matters more than the skill body. The model reads that one line to decide whether to load the skill at all, so a vague description means a well-written skill that never activates. That single line deserves more attention than the body it guards. A skill is a checklist with opinions, not documentation. The ones that work say "do X, never Y" and stop. The ones that flop explain what X is, which the model already knows. If a skill reads like docs, it is probably a rule or a note, not a skill. The counterintuitive one: more skills make each skill worse. With a big kit loaded, even the skills that do fire get followed less reliably, because instruction-following is a shared pool, not a per-file budget. Trimming the always-on set improves adherence on what is left. Less is genuinely more here. Skills should delegate to each other, not repeat each other. Two skills with overlapping doctrine drift apart over time and then quietly contradict each other inside one context window. Better to point them at a single source than restate it. Two open-source examples on GitHub, free and MIT. Disclosure, we built them: - github.com/MrBridgeHQ/human-writer-en (ships a runnable script that scores how AI-detectable a draft reads, 0 to 100) - github.com/MrBridgeHQ/github-profile-optimizer (the meta one, it audits and helps publish your own skills) What patterns have others run into shipping their own? submitted by /u/MrBridgeHQ [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]

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]