Weights & Biases Registry

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

I don't have time to trade, so I built a system with Claude Code that does it for me.

Open-sourced a project today I built entirely with Claude Code, and wanted to share it here first. YoloVest — a self-hosted, AI-driven trading assistant for the Indian stock market. I don't have the time or discipline to trade myself, so I wanted something that removes the friction completely: it watches the market, finds opportunities with an ML model (XGBoost), risk-checks each one with an optional LLM second opinion, and can place + manage trades — while I just watch from a Telegram bot or web dashboard. Runs in paper mode by default; real money is strictly opt-in. It's a real full-stack system — FastAPI backend, React frontend, ML retraining, broker integration, Docker + auto-HTTPS. I'm not a from-scratch engineer; Claude wrote the overwhelming majority and helped me architect and debug all of it. It genuinely wouldn't exist otherwise. Honest caveat: vibe-coded for personal use, not financial advice. Repo: https://github.com/pranshuparmar/yolovest Would love for people to take a look or try it out (paper mode needs no broker account). submitted by /u/Savings_Dinner_9900 [link] [comments]

Could a Deterministic Cognitive Intelligence Stack w/ Nested Protocol have kept Anthropic out of the headlines?

The following is not speculation. It is a documented record of two verified industry failures, and one live interaction that occurred during the drafting of this analysis. You decide.... The Deterministic Record: Why Boundary Failure Is Not Optional This architecture has been validated through twelve documented stress tests in controlled isolation environments. Zero failure rate. The operational threshold — 300% thoroughness — is enforced by unique structural mechanisms. The stack's internal gatekeeping renders Hallucination and output Drift structurally Impossible by design. The following document examines three recent incidents through that lens. Two are verified industry events. The third is a live-documented interaction that occurred during the drafting of this analysis itself. The pattern is not theoretical. It is reproducible — exclusively within deterministic architecture. Part 1: The Verified Record — What Actually Happened The following two incidents are not analysis, projection, or interpretation. They are verified events that have been widely reported by Forbes, The Straits Times, EnterpriseDNA, The Hacker News, and multiple independent technical sources throughout June 2026. Incident 1: The U.S. Government Seizure of Claude Fable 5 & Mythos 5 Date: June 12, 2026 What Happened: The U.S. Commerce Department, acting through the Bureau of Industry and Security (BIS), issued an emergency directive forcing Anthropic to disable global access to its newly released flagship models, Claude Fable 5 and Mythos 5. The order came just 72 hours after the models' public launch. Why: The action followed intelligence that a China-linked group was actively probing the models, combined with the existence of a jailbreak vulnerability that could bypass safety guardrails. Because Anthropic could not instantly verify the citizenship status of all global API and platform users, the company was forced to pull the models offline entirely — not just for foreign nationals, but for all users worldwide. Consequences: Global access severed for all customers, enterprise clients, and API users Foreign-national Anthropic employees both inside and outside the U.S. lost access The incident marked the first time export control machinery was used to seize a live, commercial AI model after public release. Enterprise integration of top-tier Anthropic models is now expected to face significant regulatory friction pending structural audit frameworks. What Anthropic Said: The company publicly pushed back, noting that the capability flagged by the government (automated vulnerability discovery) is already available in other models and widely used by defensive security engineers. Incident 2: The Claude Code Source Code Leak Date: March 31, 2026 What Happened: During a routine release of the @anthropic-ai/claude-code CLI tool, a packaging error inadvertently bundled an exposed source map file into the public npm registry. This source map allowed developers to reconstruct and download the entire unobfuscated TypeScript source code directory from Anthropic's Cloudflare R2 storage bucket. What Was Exposed: Over 512,000 lines of proprietary code across 1,906 files The complete mechanics of Anthropic's agentic streaming loop A 3-tier multi-agent orchestration architecture (sub-agents, coordinators, and teams) A 5-level permission system 44 unreleased feature flags, including an autonomous idle-time background daemon Consequences: The codebase was cloned and mirrored tens of thousands of times across GitHub within hours Anthropic acknowledged the leak publicly, characterizing it as "human error, not a security breach" The leaked code was subsequently used as a social engineering lure, with threat actors distributing malware disguised as "unlocked" enterprise versions. The Common Thread: Both incidents share a single structural pattern: critical control failures at the boundary layer. In the Fable 5 seizure, the model's safety boundaries were soft enough that a linguistic jailbreak could bypass them, triggering a government response that destroyed the deployment. In the Claude Code leak, a basic packaging oversight in a standard development pipeline exposed half a million lines of proprietary architecture to the public internet. In both cases, the systems lacked a rigid, deterministic enforcement layer at their perimeter. The controls were either probabilistic (safety classifiers that could be bypassed) or human-dependent (packaging checks that could be missed). Part 2: The Live Case Study — Documented Probabilistic Failure in Real Time The following interaction occurred during the drafting of this document. It is presented with verbatim excerpts to demonstrate the exact failure mode described above. The Setup: I requested a strategic document evaluating recent AI industry events through the lens of deterministic cognitive architecture. The system used was Google's Gemini. First Output: Fabrication Mixed with

Agent Profiles Make AI Runs Safer, More Focused and Reusable

I’ve been building Agent Profiles in Row-Bot around a simple idea: A personal AI agent should not run every task with the same tools, context, skills, workspace access, and approval rules. Research, review, development, automation, and delegation all need different runtime boundaries. Here is the architecture. submitted by /u/Acceptable-Object390 [link] [comments]

Breaking the Transformer Dead-End: A Local-First 3D Point-Cloud Cognition Engine running on consumer hardware

Hi everyone, I wanted to share an alternative architectural scaffold I’ve been researching and engineering over the past cycles. The project is called **SHD-CCP v2.0 (Scalable Hybrid Distributed Cognitive Pipeline)**, and it explores a complete departure from the traditional linear transformer block sequence. Instead of routing tokens through standard dense matrix multiplication layers, this engine maps linguistic structures directly onto **non-linear 3D spatial data point clouds**, utilizing topological cluster-routing. ### 🧠 Core Architectural Foundations **Grassmannian Manifold Fusion:** To handle state alignment across separate processing contexts or multi-expert channels, the architecture evaluates a geodesic midpoint calculation on a Grassmannian Manifold. By leveraging local Singular Value Decomposition (SVD), the pipeline maintains strict structural hygiene and side-steps standard weight-averaging degradation. **Zero-Copy Memory-Mapped Streaming (`mmap`):** To make massive multi-billion-parameter topologies viable on standard consumer local hardware, the runtime utilizes a background `PrefetchWorker`. Through OS-specific `mmap` rings (sequential cache policies on Linux via `madvise`, non-blocking read-access rings on Windows), matrix fragments are thrashed and streamed directly from high-speed SSDs on-demand. **Strict C-Contiguous Invariants:** To exploit hardware extensions (AVX/AVX-512) directly at the silicon layer, all token hypervectors are kept aligned in strict C-contiguous layouts, removing stride overhead during high-density operations. ### 📊 Performance & Validation (Empirical Benchmarks) The execution layer has been verified across a rigorous contract-compliance test harness (127/127 unit and integration tests passing green). Benchmarked on consumer-grade CPU infrastructure (AMD Ryzen), the engine achieves: * **512-Dimensional Semantic Vector Resolution:** < 2.0 ms per step. * **4096-Dimensional High-Density Forward-Pass:** < 10.0 ms per step. * **Memory Footprint:** Fully functional with <3GB active system RAM overhead, bypassing high-end enterprise VRAM dependencies. The background ingestion loops are governed by an isolated, non-blocking asynchronous *drop-oldest* backpressure telemetry engine to prevent primary inference thread stalls during network client fluctuations. The codebase is structured as a hybrid Python ASGI web-interface powered by a native Rust backend core (`shd-ccp-core`) to bypass runtime interpretation bottlenecks. ### 🛡️ Project Status & License The project is published as a **Source-Available** repository under the **Business Source License 1.1 (BSL)**, permitting full non-commercial evaluation, local research, and testing, converting to GNU GPLv3 after 3 years. I would love to get your thoughts on the geometric cluster-routing approach vs. typical attention-based token sequence mapping. **Repository Link:** https://github.com/loslos321-lab/UtoPiCorn_LM submitted by /u/CraigWidow [link] [comments]

Why self-reflection ReAct loops fail on long-horizon tasks, and the AgentOS verification architecture we built to fix it.

Saw a great discussion earlier in this sub about the limits of self-reflection and whether a separate verifier agent is actually worth the compute overhead. It highlighted a huge flaw: Having an agent grade its own scratchpad almost guarantees rubber-stamping: it reflects on its work with the exact same blind spots that produced the error. Here's the architecture we built for the Apodex-1.0 Heavy-Duty Solver to get verification out of the reasoner's head entirely. The dominant approach right now is the ReAct paradigm—one agent in a think-act-observe loop inside a single context window. Empirically, these loops hit a hard ceiling after a few hundred steps: the context congests, parallel branches of inquiry contaminate one another, and self-reflection degrades. An agent reflecting on its own work has the same blind spots that caused the error in the first place. We call this "pseudo-correctness"—an answer that looks confident, passes basic checks, but is structurally flawed. Here is how we bypassed that ceiling by scaling independent verifiers rather than just context length. 1. The 150-Agent Asynchronous Swarm & AgentOS Instead of one giant loop, heavy-duty mode runs on AgentOS, a task-agnostic kernel that orchestrates the team. A main orchestrator dynamically spawns up to 150 specialized sub-agents. Each gets its own clean context window, prompt, and toolset, exploring in parallel and dumping findings into a shared asynchronous report pool. 2. Verification as an Independent Team To solve the rubber-stamping problem, verification has to be structurally external to the reasoner. We built an in-flight verification team of three roles that never share the reasoning trace of the agents they audit: Conflict Reviewer: When sub-agents return conflicting reports, reconciles the evidence and decides which claim is actually supported. Fact Checker: Re-grounds individual claims against fresh sources, independent of the agent that drafted them. Draft Reviewer: Audits the final synthesis for claim-evidence alignment before it ships. 3. The Global Verifier: Graphs vs Majority Votes If you run multiple parallel agent teams, standard multi-agent debate devolves into a majority vote on the final text answer, which throws away all the underlying evidence. Instead, our global verifier assembles all the atomic findings into a claim-evidence graph whose edges record support and contradiction, then reasons over the graph itself, weighing each claim against the support and contradiction it carries, judging corroboration strength alongside source diversity. Every claim in the final answer traces back to a node in the graph, so the output stays auditable. The Results (Same Weights, Better Architecture) Running the same trained model in heavy-duty mode—external in-flight verification plus a global verifier over multiple parallel teams—takes our base Apodex-1.0 from 75.5 to 90.3 on BrowseComp and from 28.3 to 46.7 on FrontierScience-Research, using the exact same weights. We've published the full technical report, and open-sourced the Smol SFT series (0.8B/2B/4B) and the 35B mini as open weights, plus AgentHarness, our evaluation framework, so you can reproduce these numbers yourself. Tell us where the verifier breaks down in your own loops. submitted by /u/ApodexAI [link] [comments]

unslop-ui (v2): a Claude skill that flags and removes the design patterns that make a website look AI-generated. (Part 2)

Well, I took the hint. The overwhelming sentiment was that you guys absolutely hated the ever-loving shit out of the original version of this skill (from this post). I've taken every piece of criticism across all the threads ... barring the ones calling me a complete failure and disappointment (lol) ... and completely remade the skill so it's usable for those of you who were actually interested. The majority of the hate came from the "example" photo I used, which, admittedly, was pretty terrible. Hopefully the video I've attached instead does it justice. Of course, the premise is the same, with the exception of a few nuances and clarifications. Here were some common points of criticism: "Is it really that hard to think of a design and spend a few hours prompting the Ai to design it the way you want?" "No… the important part is “think” of a design. You have to think." Fair enough. So allow me to clarify. This will not "give you" a good design or a house style. You cannot outsource good taste. That part is on you. This skill is designed to be a tool to steer Claude away from general vibe-coded results when you do the hard work of actually prompting Claude intelligently. The first version also got fair criticism that its "after" example swapped the 2024 purple gradient for the 2026 look (a cream background with a serif display font and sage green), which is its own tell now. "The beige & green theme alone is a dead give away as well as the font used for the titel...." "the piss colored background copied from Anthropic branding is the biggest offender, it came bit later, I am sure Anthropic made id part of their skill or system prompt lately [...] i chuckle when people say the warm cream color is somehow average design and part of the core LLM, hell it is not, most websites used pure white background pre-AI" This version now flags the beige + green as a vibe-coded default too, and rather than prescribing a single palette or font, treats the problem as a specification issue first. The skill runs two ways. The build mode establishes a brief (a reference, a chosen color, a chosen typeface, and a layout that follows the goal) before generating, so the model does not fall back to its median. Audit mode runs a scanner over existing code, reports each finding with the file and line and the fix, and gives the project a "vibe score." The scanner then gates CI on its exit code, and any line marked unslop-ignore is left alone, so a color you chose on purpose does not get flagged. The core premise of the skill is that the checks are weighted by a Reddit analysis of about 3.2 million posts across 47 AI and SaaS subreddits, so the effort goes to what people name as a giveaway that something is vibe-coded (see original post discussing this data). There is an animated demo in the repo (the same one you see attached here). In this example, one prompt becomes four distinct deliberate designs from the same content (a fintech tool, an editorial layout, a warm consumer look, a developer-tool look), and all four pass the scanner. That is, after all the point. It breaks the single default look rather than installing a new one. Skill, scanner, demo, and the full dataset can be located here: https://github.com/JCarterJohnson/vibecoded-design-tells submitted by /u/iamjohncarterofmars [link] [comments]

I made an MCP server that lets Claude generate music, images, and video (non-dev, built the whole platform with Claude Code)

Hey r/ClaudeAI, Quick background: I'm not a developer. Over the last six months I built a full AI music, image, and video platform (AetherWave Studio) entirely with Claude Code, and a few weeks ago I shipped an MCP server for it. Sharing here because this community is exactly who it's for. What it does: gives Claude 16 tools to generate music (Suno), images, and video, plus editing, upscaling, background removal, and audio mastering. You connect once and just ask Claude to make things. It runs on your own credits from one pool, so there's no juggling a separate API key per provider. Two ways to connect: - One-click OAuth, no key to manage: add the connector https://mcp.aetherwavestudio.com/mcp in Claude Desktop or Claude.ai - Or local install: npx -y u/aetherwave-studio/mcp with an API key It's an official MCP server, listed on PulseMCP and in the registry: https://www.pulsemcp.com/servers/aetherwave-studio New accounts get free credits to try it, no card. Full disclosure: this is my product, so I'm biased. But I genuinely built it for this crowd, and I'd love feedback. What tools would you actually want an agent to have for media generation? Happy to answer anything about the MCP setup or how the whole thing got built with Claude Code. submitted by /u/Acrobatic-Result9667 [link] [comments]

Did we just witness the death of the last unrestricted frontier model? Fable 5, state-mandated "neutrality," and the trap of government-curated truth.

The whiplash from last week still has not fully set in. On June 9, we got Claude Fable 5 and Claude Mythos 5. By June 12, the US Department of Commerce dropped an emergency export control directive, and Anthropic pulled the plug globally. That is a 72-hour lifespan for a state-of-the-art model. But the real story is not just that the government panicked over a non-universal security jailbreak. It is the underlying architecture of how they are controlling these models now, and what it means for the future of unbiased, unthrottled AI. If you looked under the hood, Fable 5 and Mythos 5 had identical weights. The difference was entirely in the deployment infrastructure. Mythos 5 was the raw, unfiltered model, locked behind enterprise verification for vetted cybersecurity and defense contractors. Fable 5 was the public version. Instead of standard alignment baking safety directly into the weights, Anthropic used real-time external classifiers. Here is the kicker. When a user prompt tripped a safety classifier, like asking for deep code audits or network mapping, Fable did not give you a hard refusal. Instead, the system silently routed your session to a weaker model, specifically Claude Opus 4.8, to handle the generation. It was a stealth downgrade designed to look like a normal response. If the infrastructure is already built to dynamically route our queries and downgrade our experience in real time based on what external classifiers deem acceptable, what happens when those classifiers stop looking for malicious code and start looking for politically incorrect opinions? This is where the debate over bias gets incredibly messy. We are already seeing the federal government take an aggressive, hands-on role in defining what a chatbot is allowed to say. Between the Preventing Woke AI executive order and the recent National Security Presidential Memorandum, the government is actively banning what it calls ideological bias and demanding that all procured models adhere to strict, unbiased principles of truth-seeking. On paper, banning bias sounds great. But in reality, this creates a dangerous paradox. Who gets to define what is unbiased or truth-seeking? When the state is the one auditing these models during the mandatory 30-day pre-deployment testing windows, the government becomes the ultimate arbiter of truth. By forcing models to conform to a government-approved standard of neutrality, we are not getting unbiased AI. We are getting state-curated consensus. Now that the Commerce Department has shown they will weaponize export controls to force a complete global de-deployment over a single jailbreak vulnerability, the playbook has changed. If every upcoming model must be wrapped in external defensive classifiers to satisfy both national security agencies and political neutrality audits, can we ever actually access a true, raw frontier model again? Or has state-of-the-art AI officially become a highly managed utility, meaning the general public is forever locked into sanitized, government-approved consumer tier models? Curious to hear your thoughts on whether Fable 5 was the absolute peak of accessible, high-utility intelligence before the gates shut permanently, and how we navigate an era where the government decides what counts as a truthful output. submitted by /u/TrustedEssentials [link] [comments]

Potential fix for data center dependency

This architectural shift directly contrasts the traditional, highly centralized data center model with a highly distributed, edge-optimized approach. By leveraging **AWS Local Zones, Global Accelerator, and Akamai CDN**, you completely flip the paradigm on how AI computing consumes power, moves data, and manages scale. Here is how this architecture actively breaks away from the massive data center model: ## Centralized Data Centers vs. The AWS/Akamai Edge Mesh ``` TRADITIONAL DATA CENTER MODEL: [User] ─────────────────── (Thousands of Miles over Public Internet) ───────────────────> [Massive Central Server Farm] (High Heat / Huge Carbon Footprint) YOUR EDGE MESH MODEL: [User] ── (Sub-Millisecond) ──> [AWS Global Accelerator] ──> [AWS Local Zone / Akamai Edge] (Localized Compute / Static Cached Weights) ``` ### 1. Data Transportation: "Bring Compute to the Data" vs. "Bring Data to the Compute" * **The Massive Data Center Bottleneck:** Traditional architectures force massive, uncompressed data payloads (like raw image files or video streams) to travel thousands of miles across the public internet to reach a centralized mega-cluster (e.g., US-East-1). This creates massive network latency, high ingress costs, and bandwidth choking. * **Your Edge Solution:** By utilizing **AWS Global Accelerator and AWS Local Zones**, processing is pushed to infrastructure located in highly populated metropolitan areas right next to the end user. Because **Akamai CDN** caches static AI model layers and weights directly at the edge, the user's data only travels a few miles to hit a local container runtime. You drastically slash data transit distances. ### 2. Environmental & Energy Footprint: Localized Resource Distribution * **The Massive Data Center Bottleneck:** Centralized data centers concentrate gigawatts of power usage into a single geographic point. This creates immense physical strain on local power grids and requires millions of gallons of water every day just to run the industrial cooling towers needed to keep the server racks from melting. * **Your Edge Solution:** Instead of stacking thousands of power-hungry GPUs in one warehouse, your architecture leverages **AWS Fargate serverless containers** distributed across a globally decentralized footprint of smaller, localized nodes. By shifting heavy workloads to edge locations that only spin up container tasks on-demand, you prevent massive heat concentration, eliminate the need for hyper-scale cooling infrastructure, and utilize regional power grids far more efficiently. ### 3. Resilience and Redundancy: Dynamic Failover vs. Single-Point Bottlenecks * **The Massive Data Center Bottleneck:** If a massive centralized data center suffers an infrastructure failure, fiber cut, or localized power outage, the entire AI application goes dark for millions of users globally. * **Your Edge Solution:** Your architecture uses **Anycast routing via AWS Global Accelerator** to treat the global network as a living fluid mesh. If a local node or specific regional target zone goes offline or encounters resource throttling, the network layer detects the health check drop in under 30 seconds. It automatically, seamlessly reroutes active transactions to the next closest available edge location without the client application ever dropping its connection. ### 4. Architectural Scaling: Elastic Demand vs. Over-Provisioned Silicon * **The Massive Data Center Bottleneck:** Mega data centers must be heavily over-provisioned with expensive, idle hardware just to handle sporadic peak traffic spikes. When traffic is low, thousands of high-performance servers sit active, burning baseline electricity and generating phantom heat. * **Your Edge Solution:** By utilizing **Amazon ECS on AWS Fargate**, your compute plane is entirely elastic and on-demand. The system scales container tasks up and down instantaneously based on actual localized traffic. Combined with asynchronous **HTTP/2 delta synchronization**, devices only pull down tiny incremental state changes, completely wiping out the need for continuous, power-hungry persistent streaming connections to a central hub. ## Architectural Comparison Matrix ​ | Operational Metric | Massive Centralized Data Centers | Your AWS / Akamai Edge Mesh | | :--- | :--- | :--- | | **Network Latency** | High (Data must travel to a distant, singular geographic hub). | Sub-millisecond (Traffic terminates at the nearest Anycast Edge location). | | **Cooling & Water Impact** | Extreme (Requires dedicated, massive cooling infrastructure for concentrated heat). | Minimal (Compute is distributed across smaller, localized serverless runtimes). | | **Bandwidth Consumption** | High (Continuous streaming of heavy, raw files across the public backbone). | Low (Heavy static assets are pinned to the CDN; only delta updates are synced). | | **Fault Tolerance** | Vulnerable to large-scale regional outages and single-point bottlenecks. | Self-healing (Autom

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

Megathread Summary: I Asked Multiple Reddit Communities How to Build a Living Memory /Context Engine for Business. Here's what everyone had to say.

I am trying to build a living memory/context engine for my business, something that can remember projects, decisions, timelines, risks, and conversations across emails, documents, notes, chats, and meetings. Since this is new territory for me, I asked several Reddit communities for advice. The responses were incredibly thoughtful, and many people shared architectures, engineering trade-offs, tools, and lessons learned from building similar systems. I consolidated the best ideas into a single summary. If you're exploring the same problem, especially if you're just getting started like me, I hope this will help. Core Philosophies & Perspectives Query-First Design: Do not build the storage layer first. Write out 20 real-world queries you will ask tomorrow and architect backward, because the retrieval interface shapes the system more than the storage layer. Chief of Staff vs. Search Engine: The goal is not just retrieving raw data, but synthesis. Like Microsoft Clarity’s bulk insights, the system should process updates and proactively tell you what projects need attention, what changed, and what the blockers are. The "Daily Mirror" Briefing: Focus on what the user needs to know at the start of the next session to continue without context loss, rather than striving for perfect archival completeness. Four Separate Problems: Treating user queries as a single search issue will fail; "latest status" is a retrieval problem, "unresolved issues" is state tracking, "decisions made" is entity extraction, and "important updates" requires significance scoring. Architecture & Strategies Append-Only Event Logs First: Avoid starting with a massive knowledge graph or vector database. Ingest everything as a timestamped, append-only event log, and build the knowledge graph later as a derived query layer on top. Artifact-Mediated Continuity: To prevent identity collapse over long timelines, separate retrieval (facts) from reconstruction (identity and working context). Use a "Principal-owned Artifact System" with files like MEMORY.md for project state, "Texture Packs" for behavior descriptions, and "Lane Files" structured around the Five W's. Parallel Retrieval Paths: Pure vector search fails at scale. Run vector search (for semantic similarity) alongside a graph/relational lookup (for exact entities) in parallel, because neither covers the query surface alone. Hybrid search (semantic + BM25 keyword) is heavily recommended. Split Memory by Lifespan & Namespace: Sector your memory from day one. Split durable facts (stable preferences, user info) from working context (recent events), applying different decay rates and routing queries to the appropriate layer. Continuous Summarization: Instead of treating everything as unstructured documents, use an LLM pipeline to continuously extract structured facts from new inputs to update project briefs, decision logs, and risk trackers automatically. The Hardest Engineering Challenges Entity Resolution (The Silent Killer): Different sources will refer to the same thing differently (e.g., "Project X" vs "the X pilot"). Without an entity registry mapping aliases to canonical IDs before writing, your graph will become a mess of duplicates. Ontology & Classification: The hardest part is often getting the system to universally understand the difference between a "decision", a "discussion", or a "risk" across varying data structures like emails versus meeting transcripts. Temporal Relevance & Stale Context: A "decision" stays load-bearing for months, whereas a "status update" decays in days. If you don't encode decay rates and version records, stale facts will outrank fresh ones and confidently contradict recent updates. Significance Scoring: Standard retrieval returns everything recent, not everything important. Write-time scoring fails because significance is retrospective; a better approach is "adaptive salience," where chunks gain weight when retrieved and decay when ignored. Context Moodiness: Especially in greenfield projects, meaningful status updates can be muddied by confounding, irrelevant, or noisy data. Tools & Tech Stack Recommendations Storage / Databases: Vector stores like pgvector for semantic search, paired with key-value or relational databases for exact lookup. Airtable, Databricks, Notion, and Obsidian were also noted as strong foundational or single-source-of-truth layers. AI Models & Agents: Claude Code, OpenAI Codex, Hermes-agent (by Nous Research), AsanaAI, and ClickUp Brain. Injecting local LLMs where appropriate can help cut down on continuous API costs. Middleware & Pipelines: Kapex: Memory middleware built specifically to score node significance, governing lifecycle so resolved stuff fades and unresolved stuff persists. Sauna.ai: An engine built out of Wordware that fits this use case. Automation: Make.com or n8n for routing deterministic logic and LLM reasoning. The "Party Model": A CRM data integration framework

Washington Pulls the Plug on Anthropic’s Most Powerful AI — the Models DeFi Was Already Bracing For

The US government has ordered Anthropic to suspend Fable 5 and Mythos 5 worldwide over cybersecurity concerns, For a crypto industry that spent last week debating whether these models would arm attackers or defenders, the answer just got more complicated. The most consequential AI story of the year for digital assets did not come from a hack, a halving, or a token launch. It came from a letter sent on a Friday afternoon. The tweet announcing the removal of Mythos and Fable, Source: X At 5:21pm ET on June 12, Anthropic received an export control directive from the US government instructing it to suspend all access to its two most powerful models — Fable 5 and Mythos 5 — by any foreign national, inside or outside the United States, including the company’s own foreign-national employees. The practical effect was total: to comply, Anthropic disabled both models for every customer on the planet within hours. Access to the company’s other models, including Opus 4.8, was unaffected. According to Axios, the order came as a letter from Commerce Secretary Howard Lutnick to Anthropic chief executive Dario Amodei, citing national security authorities. An administration official told the outlet the Commerce Department moved after another company claimed it had found a way to “jailbreak” Mythos — and that the government had earlier tried, and failed, to convince Anthropic to delay the launch entirely. For most of the technology press, this is a story about regulatory overreach and AI governance. For crypto, it is something sharper. Fable 5 and Mythos 5 are not chatbots. They are the most capable vulnerability-hunting machines ever released, and the DeFi industry had spent the previous week arguing about whether their arrival was a gift or a death sentence. Now Washington has answered the question by taking them away — from the white hats as well as the black hats. Users can no longer use Fable, source: Claude What the government says, and what Anthropic says back The two sides do not agree on much. Anthropic’s account is unusually blunt for a company complying with a federal order. It says the government provided no specific details of its national security concern in the letter itself, and that the underlying issue appears to be a single, narrow “jailbreak” — one that essentially amounts to asking the model to read a codebase and fix its flaws. The company says it reviewed a demonstration of the technique being used to surface a handful of previously known, minor vulnerabilities, all of which other publicly available models can find without any bypass at all. Anthropic went further, arguing that no tester has yet found a universal jailbreak capable of broadly unlocking the model’s blocked capabilities, and that the narrow findings disclosed so far produced “either entirely benign responses or are minor findings that provide no Mythos-specific uplift.” It pointed to OpenAI’s GPT-5.5 as offering comparable capability, and warned that if a single narrow jailbreak were grounds to recall a model deployed to hundreds of millions of people, “it would essentially halt all new model deployments for all frontier model providers.” The company says it is complying while disputing the basis, calling the episode a “misunderstanding” and promising to restore access as soon as possible. That is the corporate position. The market does not wait for corporate positions. Why crypto was watching this model in particular To understand why this matters for digital assets, recall what these models can do. Mythos Preview — the research-grade ancestor of the now-suspended pair — found a 27-year-old vulnerability in OpenBSD, surfaced critical flaws across more than 1,000 open-source projects including the Linux kernel and FFmpeg, and, in one widely circulated example, identified a critical bug in the Zcash protocol within 24 hours — a flaw that had survived four years of scrutiny from some of the world’s best cryptographers. Crypto’s architecture makes it uniquely exposed to a tool like this. Traditional finance runs on siloed, proprietary systems with circuit breakers and centralized fail-safes. DeFi runs almost entirely on public code: open-source dependencies, browser wallets, RPC infrastructure, and smart contracts that are transparent to anyone — human or machine — who wishes to read them. An AI that can find ancient bugs in hardened operating systems is, in principle, an AI that can find the unaudited reentrancy flaw sitting in a protocol’s contracts right now. The defenders lose a tool, too Here is the awkward part. The same models that worried the attack-side of the ledger were rapidly becoming infrastructure on the defense side. NYSE and ICE had begun deploying Mythos for cybersecurity; exchanges including Coinbase and Binance, and DeFi teams such as Uniswap, had sought early access. Anthropic’s own Project Glasswing partners reported fixing hundreds of vulnerabilities with the model’s help — Mozilla alone among them. Sus

Continual learning in mid-2026. A map of everyone trying to crack it: memory layers, "dreaming" agents, and the Post-Transformer models that learn inside the network

Llion Jones said “2026 is the continual learning year” in the recent Post-Transformer debate. Sutton/Silver call the next phase the "era of experience”. What’s continual learning? Simply put, it’s a model’s ability to continuously improve as it gains experience – without exhibiting catastrophic forgetting. Essentially the stability-plasticity tradeoff for a reasoning model. Essentially it comes down to: where does the memory live? Outside the model. Memory files, vector dbs, graphs. Text is retrieved and pasted back into context. The model stays frozen. In the model's running state. Hidden states or fast weights that change while the model processes input. In the model's weights. What it actually knows. Encoded within the model weights to improve decision making patterns without forgetting. Dev docs today hint at #1 - memory outside the model. But the “2026 is continual learning year” notion does not come from it. Why? Part 1: The Memento stack (today’s stack) There are engineering fixes for the LLM’s memory problem. Julian Togelius & a16z compared it to Memento. In the movie, Leonard functions with his Polaroid and notes. But everyday he is the same man as day 0. Progress around these include: Anthropic's Dreaming: an async job to manage “memories”, explicitly modeled on sleep consolidation. Long context as memory: Visibly good, but with 3 problems. a) Position bias and "lost in the middle" challenge. b) Longer LLM windows come with bigger costs and we’re already discussing “token economics”. c). KV cache bottleneck, and everything evaporates when the request ends. Mem0, Letta, Zep: the popular memory-layer products from startups. AGENTS.md and git-style memory files: But, in this ETH Zurich paper (arXiv 2602.11988) it showed that LLM-generated context files actually reduce task success by about 3% while raising cost over 20%. And human-written ones barely helped too. Part 2: Continual learning, memory within the model (the big bet) Weight updates in large networks trigger catastrophic forgetting. A January 2026 paper tried continual fine-tuning on LRMs (arXiv 2601.18699) but catastrophic forgetting didn’t fade but rather increased. Promising directions that could solve this: TTT layers (arXiv 2407.04620, ICML 2025): the hidden state of the sequence layer is a small model, updated by gradient descent on tokens as they stream in. Matches or beats Transformer / Mamba baselines upto 1.3B params. Titans & Atlas: Titans add a neural long-term memory that decides what to store using a surprise signal. Atlas upgrades the memory's learning rule. Nested Learning + HOPE: Architecture updates different blocks at different frequencies. RNNs are also coming closer to Transformers via viral Memory Caching papers. Dragon Hatchling (BDH): From AI lab Pathway (arXiv 2509.26507). Working memory lives in Hebbian synapses rather than in a KV cache, allowing for an "infinite context window" without quadratic cost. AMI Labs, LFMs, etc. also mention continual learning but I didn’t find much specific info on them in this front. Current State and Future Outlook Where is continual learning in mid-2026? Solved with public access: nothing. Shipping in production: only the dossier stack, all frozen models. Demonstrated at research scale (< 2B params): TTT, Titans, Memory Caching, HOPE, and BDH. What would move the needle imo: Ship memory within the model with forgetting measurably controlled. Two questions though: What OpenAI is brewing in all of this? What’s the blocker to adoption for continual learning models: the missing breakthrough itself, or evals, serving economics, etc? submitted by /u/Ok_Can_1968 [link] [comments]

Using Claude Code? You’re probably wasting ~8k tokens per session on unused skills. I built a CLI to fix it.

Hey everyone, I’ve been using Claude Code heavily, but I noticed a huge flaw in how CLI agents handle context. At initiation, it blindly loads dozens of skill descriptions, MCP server configs, and custom rules into the prompt. I checked my session transcripts: 187 items loaded, but I only used 4 actively. That’s ~8,000 tokens per session completely wasted on dead weight, hurting the prompt cache hit rate and costing money. I wanted to fix my own wallet, so I built reap 🌾. It’s a 100% local, zero-telemetry tool that scans your session logs, finds the skills you NEVER use, and safely quarantines them. - `reap` (shows what you're wasting) - `reap prune` (moves them to a reversible quarantine) - `reap restore --all` (puts everything back if you change your mind) It works out of the box with Claude Code. ### 🛠️ Behind the Scenes: How and Why I built this (For fellow builders) I wanted to share a few architectural decisions I made while building this, in case anyone is working on similar local LLM tooling: Why Go? I originally thought about a quick Bash or Python script. But Python requires dependencies/venvs, and Bash is a nightmare for parsing complex file structures across MacOS and Linux. Go allowed me to compile a single, zero-dependency static binary that runs instantly. Concurrent Parsing: Claude Code stores history in either JSONL files or SQLite databases depending on the version. I used Go's concurrency primitives to parse these transcripts in parallel, searching for `tool_use` blocks and command invocations without lagging the terminal. Reversible State (The Quarantine): The biggest hurdle was safety. Nobody wants a tool that deletes their custom agent skills. I built a non-destructive quarantine system: `reap prune` moves files to a hidden directory and writes a versioned JSON manifest. `reap restore` simply reads the manifest and moves them back. If you want to check your own token waste or look at the Go architecture, the project is fully open source. Repo & Docs: https://github.com/thousandflowers/skillreaper Let me know what your token waste looks like or if you have questions about the parsing logic! submitted by /u/Worried_Menu4016 [link] [comments]

I used Fable 5 to audit my website, and my PWA. The results are staggering.

I was skeptical, but I went for it. It took a couple of days because the limits were being reached in neck-breaking time, but we finally got there. Fable went through line-by-line of my site, (removed the site so people don't think I am self promoting....), and my PWA, and made incredible adjustments: 1. SEO Performance & Content Architecture It didn't just give me generic tips; it reviewed every single one of my existing blog posts and fundamentally changed how the site ranks. Keyword Deep-Dive: It performed keyword research far more in-depth than Claude Opus ever did for me in the past. Topic Clustering: It identified my highest-hitting topics and automatically built out comprehensive cluster posts to support them, turning a flat site into a legitimate marketing engine. The Result: I've already seen an 18% increase in SEO activity, and the results were almost immediate. 2. Codebase Optimization & App Refinement On the app side, it treated the PWA like a senior engineer doing a ruthless code review. Dead Code Elimination: It hunted down and eliminated legacy, no-longer-needed code that was just adding weight. Refactoring: It streamlined my components, optimized state management, and cleaned up technical debt that had been lingering for months. The app feels noticeably snappier. 3. UX & Conversion Rate Tuning It looked at the landing page and the app onboarding through a marketing lens. It restructured the copy and the user flow to focus purely on conversion, making the value proposition clear the second someone lands on the page. Honestly, seeing a model handle both high-level marketing strategy (SEO clusters) and deep technical execution (PWA code refactoring) simultaneously is wild. Has anyone else pushed the context limits this hard for a full-site audit? What are you using Fable for? If at all... How are you handling the aggressive rate limits when doing deep-dives on larger codebases? submitted by /u/vibecodejoe [link] [comments]