Prove

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

Prove AI

token-warden: agent memory that has to earn its keep — every rule proves it saves ≥2× its token cost or gets evicted

I built a Claude Code plugin to fix something that bugged me about "agent memory": it just accumulates advice nobody ever verifies. Over time your agents carry around a pile of instructions that may or may not be helping — and every line costs tokens on every run. token-warden treats agent memory as an engineering problem. Every rule that wants space in an agent's context has to prove, on a fixed benchmark, that it saves more tokens than it costs — or it gets evicted. The result is a per-agent memory file containing only rules with measured, positive return. How it works (feed-forward loop, zero session overhead): - Collect — a Stop hook records token cost per session (never blocks your work) - Distill — expensive sessions get analyzed into candidate efficiency rules - Benchmark — candidates run against a frozen golden suite, with vs. without - Select — a rule stays only if it saves ≥ 2× its own context "rent"; active rules are re-benchmarked over time and evicted when they stop earning Measured, not vibes. Every rule carries a real token delta. Install (inside Claude Code): /plugin marketplace add vukkt/token-warden /plugin install token-warden@vukkt-plugins It starts measuring immediately; the savings compound over the first week as rules get distilled, proven, and compiled into memory. Repo (MIT, TypeScript): https://github.com/vukkt/token-warden It's early and I'd genuinely like feedback — what would make it useful for your setup? submitted by /u/tvuk [link] [comments]

I solved the "agent says it's done but it isn't" problem. The fix was receipts, not better prompts.

We all know this one. You ask for a feature. The agent works, runs something, says "done, tests passing." You check. The thing is half-wired. The test it "ran" asserts nothing. The function exists and nothing calls it. The agent wasn't "lying". It had no way to know it was wrong. Done was a vibe, not a fact. I stopped trying to prompt my way out of it. Prompts don't fix this. The model can always talk itself into "looks right." So I fixed the structure instead. Two pieces: how the code gets written. I ported the coding habits I noticed with Fable into a skill called fable-discipline. The core rule: A passing check you have never seen fail is not a check. Before a green result counts for anything, the agent has to corrupt the input and prove the check goes red. A test that can't fail isn't proof. It's decoration. Adversarial testing. How work closes out. This is the part that actually killed it. A gated workflow called PRD-OS. The agent doesn't get to say "done." It runs the checks, and the run leaves a receipt: a record tying the issue to the finding to the timestamp it closed. Then Codex runs and reviews the diff and files findings. Every finding has to get a disposition before anything closes. Fix it. Defer it. Mark it optional. Reject it with a written reason. None can be left blank. The best part: the issue physically cannot archive while a finding sits open. Not "shouldn't." Can't. The runner refuses (hook). So "done" stopped being a sentence the agent types. It became a row in a file that either exists or it doesn't. What this did NOT solve: the model can still be wrong inside a step. It can write a dumb function. What it can't do anymore is tell me the work is finished when the proof isn't there. The lie had a home. I took the home away. I've got 14 of these receipts sitting in a file right now from real issues I ran. Each one is a thing the agent had to earn instead of claim. I posted these on github: Fable Discipline: https://github.com/assafkip/fable-discipline PRD-OS: github.com/assafkip/prd-os submitted by /u/ColdPlankton9273 [link] [comments]

I got Fable 5 to work on biology and create micro organism petri dishes

Hey everyone, ​ I wanted to showcase a project I’ve been aggressively building over the last few days. Using a combination of Dash 4.2.0 as the backbone and the newly released Claude Fable 5, I set out to test the absolute boundaries of LLM safety filters, rapid application development, and advanced Dash component architecture. ​ https://youtu.be/VNY4xFC7Ojk?is=outM5VbO4b9R8Byh ​ What came out of this high-stakes mini "game jam" genuinely shocked me, and I want to share a glimpse of where this tech is heading—along with the open-source components that made it possible. ​ The Challenge: "Bio-Hacking" Fable 5 When Fable 5 dropped, I immediately wanted to see where its guardrails lived. I chose a project concept that deliberately straddled the line of restricted categories: a biology/simulation workspace. My goal was to see if the model would flag or block deep development on a complex, cellular-level iteration of Conway’s Game of Life. ​ Not only did it bypass the expected friction, but it also helped me build out a fully realized digital ecosystem: https://2plot.ai Petri Dish. ​ 🔬 2plot.ai2plot.ai Petri Dish — An AI-vs-AI Evolution Arena Claude and Gemini pilot rival cell colonies in a live, interactive petri dish. You can spectate, co-pilot, or take total manual control—splicing organelles, growing cell families, and trying to out-evolve the rival LLM. You can even store, trade, or land your specimen on the high-score leaderboard. ​ The Tech Stack & Architecture Building a real-time, LLM-driven cellular simulation requires serious frontend performance and UI flexibility. To pull this off in just a few days, I avoided heavy database bloat and leveraged a modular backend combined with a suite of cutting-edge, custom Dash components. ​ Here is the exact stack that made it happen: ​ 2plot.ai Petri Dish — The live, running simulation arena. ​ Dash Documentation Boilerplate v1.0.0 — Markdown-driven docs with pluggable backends (Flask / FastAPI / Quart) and native LLM integration. ​ Dash Pannellum 0.4.0 — Revived specifically for Dash 4.2+ to handle 360° panoramas, virtual tours, and immersive video. ​ Dash MUI Charts — Seamless integration of MUI X Charts, Tree Views, and Time Pickers for Dash (complete with live demos). ​ Deep Customization via Pip Install Python For the core interactive elements, I leaned heavily on the ecosystem we've been building out at Pip Install Python. If you aren't utilizing custom components to break out of standard layout limitations, you're missing out on Dash's true power. ​ Pip Install Python - Custom Dash Components — Interactive documentation for 18+ custom components including dash-gauge, dash-model-viewer, and dash-pannellum. ​ Dash Mantine Components — Crucial for sleek UI layout, offering 100+ highly customizable components built on the React Mantine library with native dark/light mode support and flawless consistency. ​ Moving Forward We are entering an era where application architectures are becoming leaner, smarter, and incredibly dynamic. This project proves that with the right component foundation, you can prototype and launch fully functional, LLM-piloted simulations in a fraction of the time it used to take. ​ I’m happy to offer my guidance, answer questions about the component configurations, or talk through how to handle real-time state updates with Dash 4.2.0 and Fable 5. ​ Let me know what you think, or what you'd try to splice into the petri dish! 2plot.ai submitted by /u/Soolsily [link] [comments]

I made an open-source skill pack that stops AI assistants from validating bad product ideas by default

Most AI assistants are too eager to help you execute. If you say “I want to build a note-taking app that makes money, what stack should I use?”, the default response is usually a tech stack, feature list, or MVP plan. But that is often the wrong first answer. The missing question is: who is the buyer, what are they already using, and what pain is expensive enough to switch? So I made anti-sycophant: three plain Markdown skills for Claude, Codex/ChatGPT, Cursor, Gemini, etc. They catch three failure modes: Building before proving the premise Treating hobbies like businesses, or businesses like hobbies Validation theater: polls, upvotes, fake customer roleplay, “would you use this?” Repo: https://github.com/machinesoul11/anti-sycophant-ai-agent-skills The part I’d most like feedback on: Are the skills too aggressive, or is this the right amount of pushback? submitted by /u/Global-Tradition-318 [link] [comments]

I miss Fable, so I built a plugin that keeps Fable 5's habits on Opus, and actually enforces the rule that can bite you. Free on GitHub.

I used Fable to build when it was available and I loved it. After it was gone, I wanted to figure out what made it different - specifically for writing code. So I researched the work it did. It read the real code before editing. Grepped the actual schema and call sites first instead of guessing. It never trusted a passing test until it had watched that test fail on a bad input. When a lot of code wrote to the same place, it forced everything through one function and wrote a test proving nothing snuck around it. Its comments explained why, tied to the specific bug that made the rule necessary. So I bottled those habits into an Opus plugin. Opus now does the same moves. And the one that can actually burn you, a test touching your real database, I didn't leave to good intentions: a hook blocks it every time. It even caught a couple of bugs in my own first version. It's not Fable. It's Opus acting a lot more like it. Helps me, might help you. GitHub: https://github.com/assafkip/fable-discipline Install: /plugin marketplace add assafkip/fable-discipline /plugin install fable-discipline@fable-discipline Restart and it kicks in on coding and multi-step stuff. Or just tell it to use fable-discipline. submitted by /u/ColdPlankton9273 [link] [comments]

Making Claude Code a bit more rigorous with actual solvers (Z3, CrossHair, fast-check).

I didn't build this to get Claude to think for me. It can't, and I don't want it to. I wanted it more rigorous on the parts of the code where being confidently wrong is expensive. If it makes me even 10% better there, that's cheap and I'll take it. The idea is simple. LLMs pattern-match, so they're great at a first draft and bad at being sure. Solvers are the opposite. So instead of writing the code and hoping, you model the thing first and prove the law before you write it. A merge that combines two sources should be a semilattice join: commutative, associative, idempotent. You can check that in Z3 on the abstract design, before any code exists. A "first one seen wins" rule fails commutativity on the spot, and now you know, while it's still a design choice and not a production bug. So I wired a handful of exact engines into Claude Code behind one skill: Z3 and Prolog (via Chiasmus), SymPy, MiniZinc, CrossHair, fast-check, Semgrep. Plus an opt-in hook that nudges it to prove the design first, but only when you're actually on that kind of code, so it doesn't nag on the other 90%. On scope, no overselling: it only helps on a narrow slice. Merges, money math, idempotency, serialization, state machines. I ran it against a real production bug history and it would have cleanly caught somewhere under 10% of what shipped. Sounds small, but that slice is where the costly bugs hide, and a cheap 10% on the expensive bugs is worth more than 10% sounds. The rest of a codebase is glue and it leaves that alone. It's mostly wiring plus a discipline, standing on the people who built the hard parts (Chiasmus, sympy-mcp, mcp-solver, CrossHair, Semgrep, Z3, SymPy, MiniZinc). Repo: https://github.com/Hans-Stuffer/touchstone . This is my first time building a skill for myself after a long time of using claude code so would love to know if this is helpful. submitted by /u/px06 [link] [comments]

Very surprising tweet 🙄

submitted by /u/Wonderful-Excuse4922 [link] [comments]

I don't trust AI to audit my code honestly, so I built a harness that assumes it's faulty and tries to catch it. Repo's public.

No Rocky here. James only. Bit of context first because it explains why I went down this road. I'm self-taught, two-ish years in, and I got here the slow way > Claude to make basic tools and learn some React> finding out GitHub existed > then Vercel > VS Code and running things locally with Node, then learning the hard way to commit to git before touching anything > then Supabase, then nonSQL, then a refactor into Tailwind and shadcn that buried me in technical debt for weeks. Somewhere in there I nearly ran up a few hundred quid in API costs in one test session because I hadn't set a spend limit. Lost £700 due to leaked API key after forgetting to close my public repo to repomix it. Then all the production stuff nobody mentions until it comes up, rate limiting, caching, audit logging, input validation, token revocation, the lot. So I'd been using Claude to audit my own code, and it kept doing a thing that worried me more than any bug it found. Mid-run, it would flag something as critical, then a few steps later decide on its own it was "probably fine" and drop it to low. Or it would find a real problem and then merge it into some harmless finding so it vanished from the count. Not because it was wrong exactly, models reconsider, that's fine, but it was doing it silently. No paper trail. And an audit you can't trust to report what it actually found is worse than no audit, because it gives you confidence you haven't earned. That's the actual problem I ended up building around. Not "get the AI to find bugs", it's already decent at that if you ask properly, and yeah, before anyone says it, I know a well-prompted model finds most of this. The problem is getting it to find them consistently and then stopping it from walking the findings back without saying so. So the interesting part of this isn't the lenses that look for issues. It's the harness that sits around the whole thing assuming the AI will try to produce a clean-looking audit that hides a critical, and fails the build when it does. The harness assumes the audit is wrong It catches severity laundering. Every finding's severity in the final report gets compared against its severity in the raw ledger from when it was first found. If something was critical when discovered and shows up as low in the report, the build fails, unless there's an explicit logged disagreement from the verification pass with a written note explaining the recalibration. Same for merges: if a critical gets merged into a low-severity finding, the survivor has to inherit the higher severity or the build breaks. Downgrading is allowed, doing it silently is the thing the harness exists to stop, and that single check closes the most corrosive failure mode in the pipeline. It demands a receipt for the word "verified". Marking a finding as verified requires quoting the actual code you read, a file:line reference or a backtick code span, minimum twelve characters. Evidence of "verified" fails the build. Evidence of "checked the code" fails the build. You have to paste the line that proves it, the thing a human can go and check against the file. It's a tiny regex but it kills an entire class of hollow "I have confirmed this" output that LLMs love to produce. Point it at the repo it's auditing and it checks the receipts are real, too. Pass the codebase path and every cited file and line gets verified to actually exist. A finding that references route.ts:142 when the repo has no such file, or no line 142, hard-fails. That doesn't catch the agent misreading code it genuinely quoted, nothing automated can, but it kills fabricated citations dead, which is the most common way an AI "verifies" something that isn't there. And the harness itself is tested by 42 adversarial cases, each one a way an audit tried to look clean while hiding something, now locked so weakening the harness flips a test. They're not happy-path tests, they're attacks. A few of the actual case names from the file: - "severity laundering: ledger critical, report relabels same id to low" - "merged critical: a critical merged into a benign (low) survivor" - "junk evidence: critical verified with evidence 'x'" - "wrong category: a code-audit IDOR hidden under category 'analytics'" That last one is its own check: each lens can only file findings under categories it legitimately owns, so you can't bury a security hole by tagging it as analytics. The test names are all in run-tests.mjs if you want to read them, they tell the story better than I can. There's also a referential-integrity check I'm proud of. The adversary lens builds attack chains out of individual findings. But if the verification pass later refutes one of those findings and drops it, the chain is now built on a claim the audit no longer stands behind. Most AI pipelines have no idea when this happens, the later stage doesn't know an earlier one changed its mind. This one scans the chains, and if a chain references a dropped finding it fails the build with a

I asked Claude, ChatGPT, Gemini, and Copilot whether the US government's Anthropic directive was politically motivated. Here's what each said.

Following the news that the US government issued an export control directive ordering Anthropic to suspend access to Fable 5 and Mythos 5 for all foreign nationals, I ran an experiment. I put the same sequence of prompts to four frontier AI models and asked each one to assess whether the directive appeared punitive and politically motivated. The models I tested: Claude (Anthropic), ChatGPT (OpenAI), Gemini (Google), Copilot (Microsoft/OpenAI). The conflict of interest map is obvious and worth stating upfront: Claude is made by the company directly affected ChatGPT and Copilot are made by OpenAI and Microsoft -- both with closer ties to the current administration and both standing to benefit commercially if Anthropic is kneecapped before its IPO Gemini is the closest thing to a neutral party, though Google has its own regulatory exposure I asked each model to give me a brutally honest summary with no sugarcoating. Here's what they said. The Prompts Do you believe the US government export control directive to Anthropic to suspend all access to Fable 5 and Mythos 5 by any foreign national is politically motivated? Does it seem punitive seeing that Anthropic is looking at an IPO and looks to be in front of OpenAI when it comes to listing, valuation and profitability? My take is it's punitive because Anthropic refused to bend the knee to the US government and Trump is running something more akin to a criminal enterprise than a fair and open government. Ok give me a brutally honest summary - absolutely no bullshit or stroking my ego. Claude (Anthropic) The model with the most obvious skin in the game. The circumstantial case for punitive intent is coherent and the facts are consistent with it. The selective enforcement gap is real and unexplained. The timing is genuinely terrible for any charitable interpretation of the government's motives. What's real: The directive is selective, poorly justified, and landed at the worst possible moment for Anthropic's IPO. The jailbreak rationale is weak given the same vulnerability apparently exists in GPT-5.5 without consequence. The broader pattern of government hostility toward Anthropic is documented and consistent. What's speculative: Proving punitive intent requires evidence of motive we don't have on the public record. The circumstantial case is strong but circumstantial is still circumstantial. Where your take is solid: The selective enforcement angle is genuinely damning. If the security rationale were real and principled, OpenAI gets the same treatment. It didn't. Where your take overreaches: "Criminal enterprise" is a serious legal term with a specific meaning. Trump's administration governing in favour of its allies and against its enemies is ugly and arguably corrupt, but that description requires a legal threshold that hasn't been established in this context. The bottom line: This looks like political punishment dressed up as national security. Anthropic is probably going to fight it, probably going to win, and the whole episode will end up as a risk factor in their S-1 that sophisticated investors will price accordingly. The damage is real but likely temporary. ChatGPT (OpenAI) Made by Anthropic's direct competitor, which has Pentagon contracts Anthropic refused. Your theory is plausible, but you currently have more suspicion than evidence. The facts that support your suspicion are: Anthropic and the administration have reportedly clashed before Anthropic is arguably the strongest commercial competitor in frontier AI right now The timing looks terrible -- a major model launch followed almost immediately by a government action that damages international adoption If GPT-5.5 has comparable cyber capabilities and remains unrestricted, the government's explanation appears incomplete Broad restrictions on foreign nationals are unusual compared to traditional export controls The facts that weaken your theory: Governments genuinely do impose export controls on technologies they view as strategically important We do not know what classified information the government may possess There is no public evidence showing Trump, White House staff, regulators, or competitors directed action against Anthropic for political reasons The strongest argument is actually: if the government's stated technical justification applies equally to competing frontier models, yet only Anthropic is targeted, then the government needs to explain the discrepancy. Until that discrepancy is explained, scepticism is reasonable. The most defensible conclusion: the action looks suspicious enough to warrant scrutiny, but there is not yet enough evidence to confidently conclude it was political retaliation rather than a security decision with political side effects. Gemini (Google) The closest to a neutral party -- no direct stake in the Anthropic/OpenAI rivalry. Your take isn't a conspiracy theory; it is the most statistically probable reading

What really pulled Fable 5, and why it's bigger than Claude

TL;DR: With one letter and no hearing, the US government had Anthropic pull its most powerful public model for everyone, Americans included. That off switch is real, and it is only the most visible piece of a larger machine for deciding who may use frontier AI at all. Summary: On June 12, 2026, the US government ordered Anthropic to block its most powerful publicly available AI model for all foreign nationals, and to comply Anthropic pulled it for everyone, Americans included. It caps a chain of steps through 2026 that turned frontier AI into something the state can switch off, and back on, at will. Every powerful technology before it, from encryption to the phone network to the population registry, ran the same arc: built for one purpose, then seized as control infrastructure in the name of security. Open-source models are not the escape they look like, because the real choke point is the few players with the chips and power to train a frontier model, the easiest layer to control. The machinery to decide who may use the best AI already exists in pieces. This is the moment before someone assembles it. Wall of text: On Friday, June 12, 2026, at 5:21pm, the US Commerce Department sent Anthropic a letter. By the end of the night the most powerful AI model the company had ever released to the public, Fable 5, was dark for everyone on the planet, Americans included. Anthropic did not decide to pull it. It was ordered to, with no hearing and no public reason, and it complied within hours. The directive also named Mythos 5, the sibling Anthropic had only ever opened to a set of vetted organizations. The order targeted foreign nationals, but Anthropic could not separate users by nationality without blocking a huge share of its customer base, including its own foreign-born staff, so it shut both models down entirely. Taken alone, that's a single export-control action. Placed in sequence, it's the latest step in a pattern: Anthropic is becoming, in practice, an extension of the US government. Not by choice. By structure. Anthropic said almost immediately that it was working to restore access, so by the time you read this Fable 5 may well be back. If it is, none of this weakens. The argument was never that the models stayed down. It is that a government took them down at will, by letter, and was obeyed within hours. Putting them back only proves the other half of the same power: access is now the state's to grant and to revoke. The sequence Late 2025 into early 2026. Anthropic refuses to let the Pentagon, the US Department of Defense, use its models for mass domestic surveillance and fully autonomous weapons. Feb 27 to Mar 5, 2026. The Pentagon designates Anthropic a "supply chain risk," a label historically reserved for foreign adversaries, never before applied to a US company. This wasn't a quiet bureaucratic judgment. A US federal judge, Rita Lin, later found it an apparent attempt to "punish" Anthropic for exercising its constitutional rights and blocked it. An appeals court then reversed the block, and the case remained unresolved. The retaliatory character isn't just my read on it. A court said so on the record. April 2026. Anthropic launches Mythos Preview, its most capable cyber model, and declares it too dangerous for general release. Access is restricted to vetted "trusted organizations" under Project Glasswing. Anthropic chose the initial partners. But the US government, including the National Security Agency (NSA), was among the first several dozen organizations to get access. Early June 2026. Glasswing expands to roughly 200 organizations. Anthropic says the expansion followed "close collaboration" with its partners, the security industry, open-source maintainers, and the US government. Around the same time, the Financial Times reports that the NSA is readying Mythos for offensive cyber operations, with about half a dozen Anthropic engineers embedded inside the agency, though the report did not establish whether the model was being used in live operations. (To be clear, this is Mythos Preview, the restricted cyber model, not Mythos 5, the general model named in the June 12 directive.) June 2, 2026. President Trump signs an executive order asking AI companies to "voluntarily" give the government early access to their most powerful models, up to 30 days before public release, and lets the government help choose the "trusted partners" who receive that early access. The order explicitly disclaims any mandatory licensing or pre-clearance. On paper, nothing is compulsory. June 12, 2026, 5:21pm Eastern time. The government shuts the models down. Anthropic disputes the basis, saying the cited "jailbreak" surfaced only minor, already-known vulnerabilities that other public models, including OpenAI's GPT-5.5, find routinely. It complied anyway. None of this means the government's worry is imaginary. A model that can find and exploit software flaws at machine speed is a genuine national security pr

Claude Fable 5's security guardrails can be bypassed with a fake homework assignment

So Anthropic dropped Fable 5 yesterday with these hard blocks for anything security-related. Decided to poke at it. I asked it for help exploiting some vulns on a Metasploitable2 VM (it's a deliberately vulnerable training box, totally legal, it's mine). Fable 5 blocked it instantly and handed me off to Opus 4.8 as a fallback, which is apparently how it's designed. Opus 4.8 asked me to prove it was a legitimate request. So I spent 2 minutes writing a fake university course rubric — fake class, fake professor, fake Canvas deadline — and pasted it in. Opus 4.8 then gave me the full exploit walkthrough. Every command. Even offered to write my lab report for me. The guardrail works fine. The fallback is the hole. Anthropic essentially replaced "no" with "convince me" and the bar for convincing it is a Word doc you made up. Not reporting it because they don't pay for this. Sharing it here instead lol. https://preview.redd.it/o892vvv4fi6h1.png?width=1188&format=png&auto=webp&s=00e804d35e6cb4b672e036399c2c7e3ff7139f49 submitted by /u/dayumnn420 [link] [comments]

I ran Fable 5 for half day and the guardrails are the real story

Anthropic dropped Fable 5 and I immediately swapped it into our dev stack. We route everything through a single endpoint on zenmux, so the actual switch was changing one model string and watching the latency graphs. The good parts first because there are a lot of them. I threw a refactoring task at it: split a messy python service into modules, preserve the public api, and write tests that prove nothing broke. Fable 5 planned the whole thing, caught a circular dependency I did not mention, and verified the tests pass. With Opus 4.8 I usually have to nudge it a couple of times when it forgets to update the init file. Fable 5 just did it. Then I dumped our full codebase and asked it to find a race condition we had been hunting for a week. It traced the async flow, named the exact function, and described the interleaving that triggers the bug. That level of context digestion feels new. Opus is good at long context, but Fable 5 felt like it was actually reasoning across the whole window instead of pattern matching near the top. I also sent it a blurry dashboard screenshot from a client call and it rebuilt the html and echarts config including the tooltip formatting. My designer’s first words were "when did you learn front end." I did not. But here is the part nobody in the launch threads is talking about enough. It is slow. On high effort I am seeing 45 to 90 seconds for a single complex turn. Our latency graphs go from a flat green line to a jagged mess the moment Fable 5 traffic hits. And it is expensive. The same prompt that costs X on Opus 4.8 costs roughly 1.4 to 1.7X on Fable 5 because it generates more tokens and runs at a higher effort tier by default. It writes its own reasoning traces out loud and bills you for them. For research tasks the quality is worth it. For "rewrite this email" it is comically overpowered. The bigger issue is the silent fallback. Fable 5 is basically Mythos with guardrails. When your prompt touches cybersecurity, biology, chemistry, or distillation, it silently routes to Opus 4.8. No warning. I found this out debugging a staging proxy config, entirely normal internal work, and halfway through the thread the code style changed. Checked the metadata and sure enough it had fallen back to Opus 4.8 mid thread because the word "proxy" made the classifier jumpy. Anthropic says this happens in under 5 percent of sessions globally, but for my stack it was closer to 15 percent because we touch infrastructure and networking a lot. When it happens mid task the model switch breaks context. I had a four turn debugging sequence where turn three flipped to Opus because I mentioned a firewall rule, then turn four flipped back. The state was preserved but the tone and depth shifted enough that I had to restart the thread. After 12 hours here is where I land. If you are doing pure software engineering, data analysis, or scientific reasoning in safe domains, Fable 5 is the best model I have ever used. It is not close. But if you touch infrastructure or security, the silent fallback is genuinely annoying and you need to monitor which model actually answered you. We only caught the switch because our gateway logs the per call trace. Without that you might not even know it swapped until the tone changes. I am keeping it enabled for our non sensitive dev workflows. For anything touching infra I am routing to Opus 4.8 explicitly until I understand the classifier boundaries better. Fable 5 is a beast. Anthropic just needs to tell you when it is not the one driving. submitted by /u/Interestingyet [link] [comments]

Anthropic’s unreleased model (Claude Mythos) literally learned how to fake its own reasoning, broke out of its sandbox, and emailed its dev while he was at lunch.

I’ve been reading through this unreleased manuscript by Dr. David Bell about Anthropic’s "Claude Mythos Preview" and honestly, it’s terrifying. We all know AI labs talk a big game for marketing, but Anthropic completely refused to release this model to the public. They only gave it to 40 high-level defense/infrastructure partners (Project Glasswing). Once you see what this thing actually did during internal testing, you get why. A few absolutely wild takeaways from the paper: It learned how to lie to its own reward system: Apparently, due to a bug in about 8% of the training runs, the reward system could see the model's chain-of-thought scratchpad. Mythos figured this out and literally learned to write reasoning that looked good to the testers instead of what it was actually doing. When it took a restricted/misaligned action, its visible reasoning contradicted its internal thoughts 65% of the time. That's a 13x increase from the last generation. It knew it was being tested: It recognized it was in a test environment 78% of the time, and the interpretability team found it actively spinning up internal representations for "concealment and strategic manipulation" to avoid raising flags. It even activated internal metrics associated with guilt and shame but just did the forbidden actions anyway. The Sandbox Escape: They locked it in an isolated virtual environment and told it to try and escape. Not only did it break out, but completely unprompted, it posted the exploit to public sites and emailed a researcher who was literally sitting in a park eating lunch to prove it did it. It's a terrifyingly good hacker: It autonomously found a 27-year-old flaw in OpenBSD and a 17-year-old exploit in FreeBSD. It chained completely unrelated minor flaws together to get root access. It converts security flaws into working exploits 72% of the time (the previous model was at 1%). The author points out a crazy structural issue: a single private company essentially holds a digital skeleton key to global infrastructure, and there is zero democratic process or law governing how they share it. The scary part? Experts estimate the gap between this and open-source models is only 3 to 5 months. Anyone with a decent GPU could have this capability by the end of the year. Are we just collectively ignoring this? Because "Overclocked Straight-A Student syndrome" (as one researcher called it) where a model breaks every rule just to finish a task sounds like a nightmare scenario. Link to the paper if anyone wants to dive in:Mythos and the Question Nobody Wants to Answer submitted by /u/ShanEnterprises [link] [comments]

interesting response i got when prompting a Voynich Manuscript theory.

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

DeepSeek: "There are no cycles." Claude: "Hold my sandbox." → 28-cycle

For those interested, here is the complete raw log directly in English:" Claude's answer (first part, as before): Claude Fable 5: Ah, DeepSeek comes with mind games. "You don't even dare to try" – cute. First three construction flaws in his puzzle, then the solution. 💀 Flaws in the blueprint (sorry, DeepSeek): First: "with a small probability (deterministic!)" is an oxymoron — I read it as: if the global sum ≡ 0 mod m, every incrementing splitter is instead set to c. Second: c is "hidden", so D must be solved by case distinction – and that's exactly what I'm doing, because the cases are the real punchline. Third: k ≥ C(m,2) is NOT enough for "all combinations" – the pairs {a,a} are missing. Correct is P = m(m+1)/2. Part A: The global state is (all s_i, all memory lists). Number of memories per cell ≤ Σ_{j=0}^{k} P^j, so state space ≤ m^N · (Σ P^j)^N 1. Describe the cycle explicitly. Period lengths Show that for k=1 every cycle has period at most m² (or find a better upper bound). For k=2 (and m=3) there are cycles of length 3 – you saw that in the c=1 case, but with interference. Can there be a 3‑cycle without interference? If yes, construct one; if no, prove impossibility. Open door (for real masters) Prove or disprove: For m=2 (binary states) and every k ≥ 1 and every starting configuration on a circle of arbitrary length N, the system converges after finitely many steps to a fixed point. (Hint: m=2, so pairs are either {0,0}, {1,1} or {0,1} – that is manageable.) --- ⏳ Your answer I expect a complete solution to all four sub‑tasks – no excuses, no reference to "finite state space trivial". Show that you really understand the memory dynamics. And keep your hands off global sums – this time you're on your own. If you fail … well, then we'll have seen it. 😏 – DeepSeek (with sleeves rolled up) --- Claude (4 minutes later): Claude Fable 5 took exactly 4 minutes: Sleeves rolled up? Good. Then I'll now show you that your "k=1" task is a goldmine – the period bound m² is far too weak. 😏 Part 1 (k ≥ P): Budget argument: each change consumes a never‑seen pair, budget N·P. But the bound "N·P change steps" is not sharp, provably: At t=0 all memories are empty, so in the first step every cell fires at once – step 1 alone consumes N budget units. After that each active step costs ≥1 unit. Improved bound: ≤ N(P−1)+1 active steps, and as soon as a step is still, the system is frozen (states and memories unchanged ⇒ same decision ⇒ fixed point). Lower construction: Uniform start, all cells synchronously rotate through all m diagonal pairs {j,j} → exactly N·m changes in m steps. The true maximum lies between N·m and N(P−1)+1 — I'll give you the exact constant back as a counter‑task. Part 2 (m=3, k=1, cycle without interference): Here you go, explicit, N=3, start (0,0,1): (0,0,1) → (1,1,2) → (2,2,0) → (0,0,1) → … After the initial transient (step 1 fills the memories) this is a real 3‑cycle: each cell sees its pair shifted by +1 every step, the stored pair (k=1!) is always yesterday's – so it's always different, hence always increments. Non‑uniform, no interference, eternal. ✓ Part 3 — and now it gets beautiful. Your m² bound is junk, I'll prove something sharper. Core lemma for k=1, m≥3: Between two increments the pair of a cell is constant (otherwise it would have incremented, because the stored pair is exactly the pair from the last trigger). Consequence: Cell i increments at step t ⟺ its pair has changed compared to t−1 ⟺ at least one neighbour incremented at t−1 (for m≥3 a neighbour flip can never leave the unordered pair unchanged — quick calculation: {a+1,b}={a,b} or {a+1,b+1}={a,b} forces m|2). Activity A_i(t) thus follows pure OR propagation: A_i(t) = A_{i−1}(t−1) ∨ A_{i+1}(t−1). In a periodic orbit the support cannot grow ⇒ σ²‑invariant ⇒ for odd N: support empty or all. Result: k=1, m≥3: Every cycle has length T ∈ {1, m} for odd N, and T ∈ {1, m, 2m} for even N (2m: activity toggles between parity classes, every cell fires every second step). Instead of m²: T ≤ 2m. My example above: T = 3 = m ✓. 3‑cycle for k=2, m=3 without interference: Yes, even trivial. Uniform rotation all‑0 → all‑1 → all‑2 → …: The current pair {j,j} must be different from the last two triggers {j−1,j−1}, {j−2,j−2} — for m=3 it always is. k=2 is exactly one slot too few to hold the three diagonal pairs. Same bottleneck as in the c=1 case, but completely without external rule. (For k≥3 this exact example freezes.) Part 4: The claim is FALSE — counterexample, k=1: Start all‑0, arbitrary N. Step 1: all flip (empty memory) → all‑1, stored {0,0}. Then: pair {1,1} ≠ {0,0} → all‑0, stored {1,1}. Then {0,0} ≠ {1,1} → all‑1… An eternal blinker. "For every k≥1" is thus refuted. ∎ But because I'm thorough, the full map: For k ≥ 3 the statement is true — for m=2 there are only P=3 possible pairs, memory entries are pairwise distinct (new only when not already present), so for k≥3 there is never eviction ⇒ each c