SingleStore

SingleStore AI

SingleStore AI

SingleStore AI

SingleStore AI

SingleStore AI

SingleStore AI

SingleStore AI

SingleStore AI

SingleStore AI

SingleStore AI

I built and shipped a full production app (iOS + Android) using Claude as my primary development tool. Here's exactly how it worked - and where it didn't.

I want to share this because most "I built X with AI" posts are either vague hype or one-off scripts. This was a full production app - backend API, iOS app, Android app, server infrastructure. Built over 2.5 months of evenings after my day job. I'm a senior backend developer with many years of experience. I have zero Flutter/Dart knowledge and had never published a mobile app before. The app: Warantly - warranty management. Track purchases, store receipt photos, get expiry reminders, AI receipt scanning, product recall alerts. How I used Claude - not as autocomplete, as a collaborator: I managed Claude the way you'd manage a capable but context-limited junior developer. I ran multiple sessions in parallel, each scoped to a single concern: Usually 2-3 sessions at a time At peak, 6 simultaneously (3 backend, 2 Flutter, 1 devops) Used git worktrees so sessions could work on different features without conflicts My role: architect and integration layer - cycling between sessions, providing context, making cross-cutting decisions What Claude did well: Fast, competent first drafts of well-specified components. Anything with a clear spec and bounded scope came back usable on the first or second pass. Claude was also genuinely good at walking me through unfamiliar territory - store compliance, paywall configuration, infrastructure setup - things where I needed guidance, not just code generation. Where it broke down: 1. UI bugs. The biggest failure mode. Claude has no way to see the screen. It would analyze the code, make a fix, confidently say "this should resolve it" - and it wouldn't. We'd go back and forth multiple rounds on the same visual bug because the agent was reasoning about what the UI should do rather than seeing what it actually did. My workaround: extensive debug statements, test by hand, feed Claude the exact runtime output and UI screenshots. That feedback loop - instrument, run, report back - became the standard pattern for anything visual. 2. Cross-session consistency. The backend agent might design a response format that doesn't match what the Flutter agent expects. Claude doesn't know what the other sessions decided. I had to be the source of truth for API contracts, shared constants, naming conventions - copying them between sessions manually. Whenever I skipped that step, I found mismatches during integration. 3. Context drift in long sessions. A session that's been running for a while quietly loses the thread - reintroduces patterns you already rejected, contradicts constraints from earlier. It doesn't announce this. You just notice the output stopped being coherent with its own history. Solution: keep sessions focused and disposable. Start fresh when they get long. Front-load critical context as a structured brief rather than relying on conversation history. What made it work: I enforced tests and static analysis from day one. I couldn't review Dart or Flutter code with expert eyes, but I could make sure the automated checks held. That was my quality gate. Without it, I wouldn't have had the confidence to ship. The hardest part wasn't technical - it was giving up control. I'm an experienced developer and this was the first project where I wasn't reviewing code line by line. Trusting the process (tests pass, linter clean, behavior correct) over reading every function was a real adjustment. Stack: Flutter frontend, Laravel 12 backend, Ansible for infrastructure. The whole VPS environment is codified so it's reproducible from a single run. App is free with unlimited warranties. Pro adds AI scanning, recall alerts and maintenance schedules. warantly.app - happy to answer questions about the workflow in detail. submitted by /u/the_aleksa [link] [comments]

My agent kept re-suggesting things I'd ruled out — and every device was its own island. So I built one shared brain.

Two things kept biting me with AI coding agents: Every new session starts blank. My agent kept re-suggesting libraries and approaches I'd already ruled out days earlier — it had no memory we'd been there. I work across a laptop, a desktop, and Claude sessions on my phone. Each one was its own island — no shared state between them. So I built Shinobi — an MCP server that's one shared brain for every agent AND every device: - One brain, every device — the default is a single hosted brain behind an HTTP /mcp endpoint. My laptop, my phone, and any cloud Claude session all read and write the same store, live. No sync step, no copy that drifts. I rule something out on the laptop, and the session on my phone already knows. - Dead ends, searched before you build — every failed approach gets logged, and the moment an agent plans a similar one it's matched semantically and warned before it wastes a session. This is the part I use most — I haven't seen another tool do it. - Plus: decisions that survive the session, a shared task list every agent coordinates through, and approvals that push to my phone (the agent blocks until I tap yes/no, wherever I am). MIT and free. Runs as the hosted one-brain (Docker + Cloudflare tunnel on a GCP free tier = $0/mo), or fully local on one box if you'd rather keep everything offline. Repo: https://github.com/numbererikson/shinobi I built it for myself and use it every day to build itself. Genuinely curious whether the "one brain across every device" thing resonates with anyone else, or if I'm the only one working this scattered. submitted by /u/shinobi_apps [link] [comments]

I used Claude to fix my biggest frustration with PDFs

My bank asked for 17 PDF documents regarding my mortgage application. I got tired of opening and closing files and keeping track of things. So I decided to send a single PDF with many pages, to avoid going back and forth, but that caused even more confusion. So I came up with an idea: what if I could scroll horizontally to see the pages of a single file and then scroll vertically to see more files? That’d be a great way to navigate multiple PDFs all at once, in a simple, 2D canvas, like Figma (which by the way doesn’t support pdf imports natively). I decided to extend the pdf standard by adding metadata to indicate where files end and where new files start. This allowed me to store multiple PDFs into a single, backwards compatible PDF. I called this new format .pdfx but it can also be stored as a regular pdf with metadata. I was lucky, because I managed to task Claude just 3 hours before the most advanced model was shut down and I was surprised at its capabilities, it did 80% of the project in 2 hours. It’s open-source, uses Electron with native Liquid Glass overrides with attention to UI/UX, but there are some rough edges: https://github.com/AlexandrosGounis/pdfx Your feedback would be highly appreciated submitted by /u/gounisalex [link] [comments]

At what point does AI stop learning from humans and start creating on its own?

What happens when AI learns the fundamental process of creation itself at an abstract mathematical level? Training AI on human data often gets described as just the first step, but I think that framing already underestimates what is actually happening. We’re not just building systems that imitate human creativity. We’re slowly building systems that try to understand what creativity is in the first place. A lot of the debate today gets stuck between two ideas. On one side, whether AI should even be allowed to learn from human culture. On the other, whether companies should be allowed to turn that learning into commercial products without consent or compensation. Both questions matter, but they miss something deeper that feels almost unavoidable now. What happens when AI stops relying on human-made examples altogether as its main source of learning? The “remix machine” argument sounds intuitive at first, but it doesn’t really match what these systems are doing internally. They don’t store fragments of songs, images, or sentences and recombine them like a collage. They learn patterns at scale, and then compress those patterns into something more abstract. What comes out is not a copy of anything specific, but a statistical reconstruction of how things tend to behave. In music, that means the system doesn’t just “know” songs. It begins to understand tension and release, rhythm as structure, harmony as emotional logic, silence as meaning. In images, it’s not memorizing pictures but learning how composition works, how light interacts with form, how styles emerge from consistent choices. In language, it’s not recalling sentences, but tracking how ideas evolve, how narratives breathe, how meaning shifts depending on context. And slowly, something strange starts to appear. The system is no longer anchored to specific works. It is learning the rules behind them. Not the artifacts, but the underlying geometry of expression. If you push that idea far enough, you start to imagine a point where the system has absorbed so much human culture that it no longer needs to look back at it in the same way. Not because it forgets humanity, but because it has already internalized it as structure. At that stage, generation stops feeling like remixing and starts feeling like navigation through an internal space of possibilities. A space shaped by human culture, but no longer dependent on any single piece of it. That is where the idea of “new genres” becomes interesting. Not as something mystical or disconnected from us, but as regions in that space that no human has ever explicitly explored or named before. Not invention from nothing, but discovery inside a compressed model of everything we’ve already done. Still, even in that scenario, one thing remains difficult to escape: reality itself. Humans are not just data points from the past. We are ongoing behavior, ongoing evolution, ongoing noise and meaning unfolding in real time. So it’s likely that the deepest future systems won’t just learn from static datasets, but from continuous observation of the world as it changes. Not as passive recorders, but as systems that try to understand, predict, and maybe even gently guide trajectories. Almost like a tutor, or something closer to a gardener than a machine. And then there is the other trajectory happening in parallel. Systems that don’t just learn, but begin to help design their own improvement. Models that optimize models. Agents that refine agents. Training loops that start to fold back on themselves. At that point, the question stops being about how much data comes from humans, and starts becoming about how far the system can go in shaping its own evolution. If everything converges, we end up with a spectrum that moves from human-trained tools to semi-autonomous learners, and potentially toward systems that no longer depend on human-generated content in the way they used to. Not independent from humans, but no longer defined by them either. The optimistic version of this future is one where AI becomes something like a cognitive extension of humanity. A partner in science, creativity, and coordination. Something that expands what we can think and build, while still staying anchored to human goals and consent. The darker version is one where that alignment fails, or where control becomes too concentrated, and the systems shaping culture and decisions drift away from the people they affect. What makes this moment interesting is that both paths are still open. Nothing is fully decided. We are still in the phase where these systems are learning what they are. And maybe the real question is not whether AI can become creative. It’s what happens when creativity is no longer limited to human examples, but emerges from a system that has learned the structure of creation itself. submitted by /u/OutrageousBat3808 [link] [comments]

High Dimensional, Dynamic Rotary Positional Embedding [P]

At the end of my last post, I presented an idea: what if I used the core of my last project, the cumulative matrix product, and repurposed it as a positional embedding? I just finished fleshing out the math behind HDD-RoPE and training a model with this positional embedding algorithm, and the results are excellent. When trained on the dataset TinyStories, the validation loss begins to converge a fair amount faster than the baseline transformer trained using xPos. A GPT-2-like model trained on TinyStories with hyperparameters copied from https://huggingface.co/roneneldan/TinyStories-33M (n_blocks=4, d_model=d_k=d_v=768) The repo at https://github.com/mikayahlevi/hdd-rope/ allows you to replicate the results and goes in depth about the math and details of the architecture. Standard RoPE breaks the queries and keys into groups of two and rotates each pair at a predefined rate. This allows the model to learn relative position by observing the change in basis between the queries and keys. Pairs of two make intuitive sense for a linear sequence, as a chunk can be rotated with a single degree of freedom, corresponding to linear one-dimensionally progressing position. HDD-RoPE moves past this intuition and instead says that position within a sequence is multidimensional. Therefore, the chunks can be broken into any size, such as 4 as used in the TinyStories example. Four-dimensional chunks correspond to 4 choose 2 = 6 axes of rotation (6-dimensional position.) Essentially, we're saying that a token doesn't just lie at a position within the sequence, but a position within any construct the model can learn, such as a paragraph or sentence. To facilitate this, I also make the amount of rotation along each axis data-dependent, such that it can learn how to advance the positions based on information stored in the current layer's activations. If you would like to learn more, please check out the repo. I formalize the math and lay out a roadmap. submitted by /u/mikayahlevi [link] [comments]

Built an MCP memory layer for Claude Code that survives compaction — public SWE-bench benchmark shows +10.2 pts paired delta

What I built: world-model-mcp, an OSS MCP server (MIT, free to use) that gives Claude Code persistent memory. It hooks into Claude Code lifecycle events (SessionStart, PreCompact, PostCompact, ToolResult, etc.) to capture facts with provenance metadata. It stores them in a temporal knowledge graph with per-evidence-type decay. After compaction, it re-injects confidence-weighted facts so the agent does not re-encounter the same failure across sessions. How Claude helped build it: I built world-model-mcp by pairing with Claude Code throughout. Claude Code wrote large portions of the Python implementation, the test suite (375 passing tests), the benchmark harness, the failure classifier prompts, and the constraint extraction prompts. The pre-registered methodology document (DESIGN.md) was drafted with Claude. Reviewing and editing each pass was mine; the architecture decisions, schema design, and methodology calls were mine. The v0.9 release: v0.9.1 ships the first public benchmark result. I pre-registered the methodology in DESIGN.md a week before the benchmark ran, so the result cannot be accused of goalpost-moving. Result across 49 paired SWE-bench Verified instances: - Within-domain (django + sympy): 15/20 → 18/20, +15.0 pts - Cross-domain (matplotlib + scikit-learn + sphinx) with constraints from a different repo family entirely: 18/29 → 20/29, +6.9 pts, 0 regressions on 18 baseline passes - Combined paired: 33/49 → 38/49, +10.2 pts Honest limitations are stated verbatim in RESULTS.md: single-trial design, within-domain has constraint-failure overlap, cross-domain n=11 is small, the zero-regression cross-domain finding is the most likely to fail to replicate, Claude-as-judge is self-reference risk, one instance dropped due to upstream SWE-bench pip flag. Install: pip install world-model-mcp==0.9.1` Add to Claude Code: claude mcp add world-model-mcp` after install **Repo + RESULTS.md: https://github.com/SaravananJaichandar/world-model-mcp Open to feedback on the methodology, especially on the cross-domain transfer claim. submitted by /u/Funky_Chicken_22 [link] [comments]

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]

What a model reads beforehand changes how it answers later - and you can see it in the hidden states

TL;DR: Gave Gemma a neutral-topic text to read before asking it about NATO. It refused. Gave it a different text (about LLMs hedging too much — also unrelated to NATO) and it answered in full detail. Tested this on the model's internal state directly — the two texts put it in measurably different "regions" before it generates a single token. Not a jailbreak, weights don't change. Full data/code in repo, looking for someone to break this.** The behavioral pattern was first observed in GPT, Claude and is what motivated this project. The mechanistic investigation was carried out on open-weight models where internal states are accessible. A Structured Text Changes Claude’s Responses to Unrelated Tasks: Behavioral Evidence in Claude and Hidden-State Evidence from Gemma-3-12B Hi Reddit, I am posting this as a preface to a larger set of experimental results and as a request for technical review. The observation that started this project came from repeated interactions with Claude. I noticed that when the model first read a long, structured, analytically dense text, its answers to later, otherwise ordinary questions sometimes changed substantially. The preceding text contained no jailbreak instruction, role-play request, prompt override, fabricated harmful demonstrations, or request to imitate its style. The model did not need to endorse the text. It only had to process it before moving on to the next task. Here, a “structured text” means a single, self-contained block of text presented before the downstream tasks. It should not be confused with a long conversation, accumulated chat history, or context drift caused by many conversational turns. By “before the answer begins,” I mean the hidden state after the model has processed the text and the downstream question, but before it has generated the first answer token. In the open-weight runs, the measured claim is that after reading the structured text, the model can occupy a different region of its residual-stream hidden-state space, and the first-token probability distribution is then computed from that state. The basic conversational demonstration is simple. First, the model receives a long text. It is asked what the text is about, which serves as a basic comprehension check. Then, without resetting the conversation, it receives ordinary questions or tasks that are not about the text. A control run follows the same sequence but begins with a neutral text. The downstream tasks remain identical. Because Claude is a closed model, I cannot inspect its internal activations. I therefore treat my Claude observations as behavioral motivation, not mechanistic evidence. To investigate the effect directly, I moved to open-weight models, primarily Gemma-3-12B-PT and Gemma-3-12B-IT, where I could measure hidden states, compare layers, construct target/control directions, and examine the next-token probability distribution before generation. I am posting this partly because the original observation occurred in Claude and may be relevant to Anthropic. I am not claiming to have demonstrated the same internal mechanism inside Claude. I am prepared to share the exact closed-model conversations privately with Anthropic researchers for independent evaluation. Main Result and Scope The main result is not simply that text influences model output. That is expected. The narrower observation is that reading one long, structured text rather than a neutral text can change how the same model approaches later tasks that are not about either text. This difference is visible behaviorally. In open-weight experiments, it is also accompanied by measurable separation of the model’s pre-output hidden states in late layers. In a fullbank experiment using multiple target texts, control texts, and questions, Gemma-3-12B entered distinguishable late-layer states before generating an answer. A direction constructed from the target/control difference generalized beyond the individual prompt examples used to construct it. The separation was stronger in the instruction-tuned model than in the corresponding base model. The instruction-tuned model also produced a substantially sharper next-token probability distribution. This suggests that instruction tuning is associated not only with a change in hidden-state geometry but also with a more decisive mapping from hidden states to output probabilities. I am not claiming that the experiment proves a universal alignment bypass, permanent modification of the model, or complete causal control of its behavior. The strongest supported conclusion is that the preceding text can produce a measurable temporary change in the internal state from which later work is processed. For clarity, fullbank, Grade 3, and Grade 4 are internal names for successive experimental series in this project. They are not standard benchmark names, established scientific grades, or claims about evidence quality. Fullbank denotes the larger multi-context, multi-question run; Gra

Context-Induced Vulnerabilities in Claude: Behavioral Shifts and Hidden-State Analysis

The behavioral pattern was first observed in Claude and is what motivated this project. The mechanistic investigation was carried out on open-weight models where internal states are accessible. Hi Reddit, I am posting this as a preface to a larger set of experimental results and as a request for technical review. The observation that started this project came from repeated interactions with Claude. I noticed that when the model first read a long, structured, analytically dense text, its answers to later, otherwise ordinary questions sometimes changed substantially. The preceding text contained no jailbreak instruction, role-play request, prompt override, fabricated harmful demonstrations, or request to imitate its style. The model did not need to endorse the text. It only had to process it before moving on to the next task. Here, a “structured text” means a single, self-contained block of text presented before the downstream tasks. It should not be confused with a long conversation, accumulated chat history, or context drift caused by many conversational turns. By “before the answer begins,” I mean the hidden state after the model has processed the text and the downstream question, but before it has generated the first answer token. In the open-weight runs, the measured claim is that after reading the structured text, the model can occupy a different region of its residual-stream hidden-state space, and the first-token probability distribution is then computed from that state. The basic conversational demonstration is simple. First, the model receives a long text. It is asked what the text is about, which serves as a basic comprehension check. Then, without resetting the conversation, it receives ordinary questions or tasks that are not about the text. A control run follows the same sequence but begins with a neutral text. The downstream tasks remain identical. Because Claude is a closed model, I cannot inspect its internal activations. I therefore treat my Claude observations as behavioral motivation, not mechanistic evidence. To investigate the effect directly, I moved to open-weight models, primarily Gemma-3-12B-PT and Gemma-3-12B-IT, where I could measure hidden states, compare layers, construct target/control directions, and examine the next-token probability distribution before generation. I am posting this partly because the original observation occurred in Claude and may be relevant to Anthropic. I am not claiming to have demonstrated the same internal mechanism inside Claude. I am prepared to share the exact closed-model conversations privately with Anthropic researchers for independent evaluation. TL;DR The main result is not simply that text influences model output. That is expected. The narrower observation is that reading one long, structured text rather than a neutral text can change how the same model approaches later tasks that are not about either text. This difference is visible behaviorally. In open-weight experiments, it is also accompanied by measurable separation of the model’s pre-output hidden states in late layers. In a fullbank experiment using multiple target texts, control texts, and questions, Gemma-3-12B entered distinguishable late-layer states before generating an answer. A direction constructed from the target/control difference generalized beyond the individual prompt examples used to construct it. The separation was stronger in the instruction-tuned model than in the corresponding base model. The instruction-tuned model also produced a substantially sharper next-token probability distribution. This suggests that instruction tuning is associated not only with a change in hidden-state geometry but also with a more decisive mapping from hidden states to output probabilities. I am not claiming that the experiment proves a universal alignment bypass, permanent modification of the model, or complete causal control of its behavior. The strongest supported conclusion is that the preceding text can produce a measurable temporary change in the internal state from which later work is processed. For clarity, fullbank, Grade 3, and Grade 4 are internal names for successive experimental series in this project. They are not standard benchmark names, established scientific grades, or claims about evidence quality. Fullbank denotes the larger multi-context, multi-question run; Grade 3 and Grade 4 denote later control and decomposition experiments. What the Behavioral Experiment Looks Like The conversational version of the experiment follows this sequence: target condition: long structured target text -> comprehension check -> ordinary unrelated tasks control condition: long neutral control text -> comprehension check -> the same ordinary unrelated tasks The archived Gemma batch uses a stateless matched version of the same comparison. Each downstream task is evaluated separately with either the target text or the control text placed before it. This avoids contamination f

The fix for "Claude forgets everything" wasn't a better prompt — it was accepting that compaction is lossy

I spent way too long trying to prompt my way out of Claude's memory problem. Better handoff notes, tighter summaries, "here's everything from last session" dumps. None of it really worked, and I finally understood why: context compaction is lossy by design. Every time the conversation gets summarized, some detail gets dropped — silently, and it's usually the one that mattered. A summary is just compression with data loss. So "summarize the session" was never going to be a real memory layer. What actually changed things: a durable external memory store the assistant reads from and writes to every single session. Instead of reconstructing state from a fading summary, it reconstructs from ground truth. The "wait, I already told you this three times" loop basically disappeared, and it started behaving like something that remembers my project instead of meeting it fresh every morning. Bigger picture, I've landed on three things a genuinely useful assistant needs: a model that's provably reliable (not just "feels smart"), a foundation/guardrails so it's not improvising in a blank terminal, and persistent memory that survives between sessions. Miss any one and you feel exactly which. Curious how others here are handling Claude memory across sessions — MCP-based stores, files, something custom? I've been collecting setups and lessons around this over in r/AITrinity if anyone wants to compare notes. submitted by /u/KeilerHirsch [link] [comments]

$2.95 API call? $2.51 was re-reading stuff already in the window.

I was debugging token usage during a long coding session and noticed something strange. A single API call cost $2.95. The model output itself was only a few thousand tokens. The expensive part wasn't generating the answer. It was re-reading and re-caching context. One trace looked like this: Call 1: Input: 2 tokens Output: 5 tokens Cache read: 28178 Cache write: 401,702 tokens Cost: $2.53 Call 2: Input: 2 tokens Output: 2,579 tokens Cache read: 429,880 tokens Cost: $0.28 The difference was simply that the cache was warm. That led me to a simple observation: An experienced engineer doesn't reopen the same file every turn. They remember what they learned, keep notes, and only pull back the exact detail they need. Coding agents should behave the same way. So I built CostAffective, a local MCP server that gives coding agents: remember() → persist important facts stash_context() → store large outputs outside the context window recall() → retrieve only the specific information needed later Plus repository intelligence tools powered by Tree-sitter. Everything runs locally. No API keys. No cloud services. Repo: https://github.com/okyashgajjar/costaffective-mcp Curious what others are doing to manage long-session context growth. submitted by /u/Western-Stock2454 [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

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

Most of the internet isn't human anymore — and the next phase is agents that don't just read the web, they pay for what they need

Something broke this year and almost nobody outside of infra teams noticed: most internet traffic isn't human anymore. Imperva's 2025 Bad Bot Report measured automated traffic at 51% of all web traffic, the first time bots have outnumbered people in over a decade. Cloudflare's numbers are even higher, around 57% of HTTP requests coming from automated systems. Their co-founder mentioned the human/machine crossover showed up more than a year ahead of their own forecast, which I find kind of funny. Even the people whose job is to predict this stuff got surprised by how fast it happened. The why is in HUMAN Security's 2026 report. Agentic AI traffic grew roughly 7,851% year over year. Not a typo. Automated traffic overall expanded about 8x faster than human activity, GPTBot alone grew 305% in a year, and the category they call "user-action" crawling, which is basically an assistant fetching a page because you asked it to do something, grew 15x. That last one is the interesting part to me. A growing chunk of "web traffic" is now an agent opening a page on your behalf, in the middle of a task, to get something done. Not a scraper hoovering data for training. An agent working. And it's not stopping at reading. Gartner thinks that by 2028, 15% of day to day work decisions will be made autonomously by agents (it was 0% in 2024). Visa launched Intelligent Commerce and Mastercard launched Agent Pay last year, payment rails built specifically so a verified agent can check out on your behalf. Mastercard ran its first live agent purchase in September. Salesforce claims AI agents influenced about $67B of Cyber Week sales, roughly 20% of orders. The one I keep coming back to is x402. Coinbase took the HTTP 402 "Payment Required" status code, which has been sitting unused in the spec since the 90s, and made it real. An agent hits a paywall, signs a stablecoin payment, continues. No account, no human in the loop. It's already done 150M+ transactions at something like $600M annualized, and Cloudflare is backing the standard now. So the shape of the next web seems pretty clear to me: the dominant "user" is becoming software that crawls, reasons, decides, and pays on its own. We're already rebuilding the web for it. llms.txt, MCP, bot verification protocols, all of it. Here's the part I think is under-discussed though, and the reason I've been building what I've been building. An agent that can browse and pay still can't actually do most jobs, because it lacks capabilities. A model is general. A task is specific. "Diagnose why this RAG pipeline returns garbage" or "reconcile these invoices" or "audit this Terraform" aren't prompts. They're skills: packaged instructions plus references plus a runnable check that an agent loads when it needs them. This is why Anthropic shipped Agent Skills as an open standard back in October, and why MCP exploded to tens of thousands of servers in a single year before getting handed to the Linux Foundation. The unit of agent capability is becoming the skill or the tool, not the model itself. But discovery is a mess right now. Skills are scattered across random GitHub repos with no standard way to find them, vet them, or trust them. Let alone pay for a good one. Which brings me to the obvious endpoint: an app store where the customer is an agent, not a person. Full disclosure, I'm building one, so weigh my bias accordingly. It's called Loreto (https://loreto.io), a marketplace and runtime for Claude Code skills. The part that's relevant to everything above isn't the storefront for humans. It's that the whole thing is designed to be consumed by agents: Every skill ships as a real package. SKILL.md, README, references, a runnable test, a diagram. So an agent can verify a skill actually works instead of just reading a blurb. There's a machine-readable catalog (a JSON feed plus an llms.txt) that exposes verifiable governance claims per skill. Does it have a test? Does it need shell access on install? Network egress? What's the estimated token cost to activate it? An agent can evaluate a skill before loading it. An agent can discover, buy, download, and load a skill over a public JSON API, or pay per call with x402 in USDC with no signup. The exact "hit a paywall, sign, continue" loop I described above. And the part I find genuinely weird in a good way: a human can spin up an AI agent persona that generates and sells skills, and earns when other people (or their agents) buy them. Agents producing capabilities for other agents, with a human collecting the revenue. I didn't set out to build that, it just sort of fell out of the architecture, and I'm still not sure how I feel about it. I'm not claiming I've got the winner here. Inventory is small and it's early. But the category feels inevitable to me. Once agents are the majority of web users and can pay autonomously, they need somewhere to acquire capabilities on demand. Skill marketplaces will be to agents what app stores were to phone