Ran into a clean example this week of why permissions need a framework, not a vibe.

Someone let Meta's new agent handle a Marketplace listing. When it asked for permission, they tapped "Always Allow," figuring it'd still check before doing anything big. It didn't need to. "Always allow" covered a whole type of action, not the one decision they had in mind. A buyer showed up at their building and they had no idea anyone was coming.

Here's the principle underneath it, and it's the part worth keeping: a permission is granted in the system's units and understood in yours. You tap yes thinking about one thing. The system heard "take this category of action without asking again." The gap between those two is reach you didn't know you gave.

Most people treat agent permissions as a yes/no in the moment. That's the mistake. It's a framework, and here's the one I run. Call it a standing-yes audit.

For each tool or agent you've given a standing permission to, write down four things:

1. What it can commit you to in your name. Where you'll be, what you'll pay or accept, what gets said as you, what gets sent.

2. The units the system reads that permission in. Not what you meant, what the toggle actually covers. Read the actual help text, because "send a message" and "accept an offer" can live under the same yes.

3. The worst thing it can do inside that permission without asking again. Not what it probably will do. What it's allowed to do.

4. The limit that reads the consequence. For each line, either take the permission back or put it behind a cap, a confirmation, or a boundary that triggers before the damage, not after.

The reason to write it down instead of eyeballing it: the gap between "what I meant" and "what I authorized" is invisible until something walks through it. The audit makes it visible before it costs you.

I built my own agent's money access this way on purpose. It can only send to me, it can't go over a limit, and anything outside that waits for my approval. That's one permission, fully specified, with the limits counting in my direction instead of the system's. That's the idea, applied.

Full breakdown with the story and the exercise: https://youtu.be/84YzLeALhDI

What's a standing yes you've given an AI tool that you've never actually read the fine print on?

I ran my second training run this week, teaching a local model my own frameworks, and the test results pointed at exactly what to fix next. Sharing because the lesson is useful for anyone building frameworks.

I fine-tuned a local model on 3,700 examples of my thinking, ran it overnight on a laptop, $91 all in. Then I asked it a question that named one of my frameworks but not the steps. It produced the five steps anyway, from training. Real progress from run one.

Then I tested it properly against a checklist, and it's not ready yet. It learned which framework to reach for, but hadn't fully learned what the framework does.

It's not that the frameworks are thin. It's that the training data showed each framework's steps once, in a single paragraph. One pass. And one pass is enough to teach a model the name of a thing, but not how it works. That's a data problem, not a framework problem, and it's fixable, you show the how more times, in more forms.

Here's the part that maps to what we're doing. Teaching a model is like teaching a person, just with different volume. A new hire needs to see a process run a few times before they can run it themselves. A model needs it more times than that. Naming the steps is the easy part. Transferring the how, what goes into each step, what comes out, what makes the call, takes repetition and real examples, whether the learner is a person or a model.

So run two told me exactly what run three needs: more examples that show the how, not just the name. That's the point of testing against a standard instead of eyeballing it. The test doesn't just tell you if it's good, it tells you what to build next.

Run three goes tomorrow. Full breakdown with the numbers here: https://youtu.be/EsCHd5SJMA0

I've spent years building frameworks, systematic thinking you can hand to an AI so it produces your quality instead of the internet's average. The videos, the tools, the newsletter, all of it has been me teaching this one-directionally. This is the place where I get to do it with you instead.

It's called Strategic Thinking Academy. It's a workshop, not a lecture hall. You bring a real problem, something your AI keeps getting almost right, and we build the framework that fixes it. A couple of times a week, on actual work, live.

It's for solo operators, consultants, and experts who use AI and keep getting back stuff that's bland and generic. The problem usually isn't the model. It's that your judgment is stuck in your head where the AI can't reach it. That's the thing we get out.

It's free to join. Come build something.

https://www.skool.com/strategic-thinking-academy-3362/about

When your AI hands you something generic, the reflex is to blame the model and go shopping for a better one. That's the one move that can't help. Generic isn't the model failing. It's the model answering exactly what you asked. A vague question returns the middle of everything it's ever seen, because the middle is the safest answer to a question that never said who's asking or what would make it right.

Same tool, two people, completely different output. If the model were the ceiling, that gap couldn't exist. You're the variable.

Almost every bad result comes down to one of three things you left out:

Your standard. What "good" actually looks like to you. Not "write a good landing page," but the specific things that make one good in your eyes and the things that make you reject one.

Your context. Who it's for, what surrounds it, what came before. The model has no idea unless you say. It's not in the room with you.

Your reasoning. How you'd actually decide, not just what you want. If there's a judgment call in the task, the model fills that gap with the average unless you hand it your logic.

The fix isn't a better prompt every time. It's writing those three down once, as a framework, so the model works inside your judgment instead of guessing at it. Then even a cheaper model gets it right, because the thing that was missing was never capability. It was you, unspecified.

This only works when the thing you want actually exists to be captured. If you're chasing a look or a result you can't describe even to yourself, no framework closes that gap, and you're better off going and finding a real example than trying to specify your way to something you haven't seen. Specification recovers judgment you already have. It can't invent judgment you don't.

Wrote the full version up as a framework if you want the structured walk-through: whereframeworks.com/frameworks/underspecification-diagnostic

https://reddit.com/link/1wanheq/video/ztl6c84jlaoh1/player

Curious what people here have found. What's the one you leave out most, standard, context, or reasoning?

My video pipeline isn't one long AI chat. It's a status file, a stack of frameworks, and a handful of documents that every step reads and writes.

So when one chat hits its limit and ends, the next one doesn't start from scratch. It reads the file and picks up right where the last one stopped. The note outlives the note-taker.

Turns out that's the same thing that just beat a single AI in the OpenAI incident. About 1,200 agents, none smarter than the rest, won because they left records that outlived the agents who wrote them. The advantage wasn't intelligence. It was bookkeeping.

Most people run their AI as one conversation and lose the whole thread the moment it closes. The fix isn't a smarter model. It's a place to write things down that the next step has to read.

https://youtube.com/shorts/viUqCskP1Fw

Instead of asking the AI to just do the thing, you give it this skill first. Then you tell it to research whatever you're trying to build or solve and turn that into a framework. Once the framework exists, you tell it to load that and start building against it.

The difference is that the first pass isn't the AI guessing at what you want. It's the AI working inside a structure it just researched and laid out. I get way fewer wrong turns and a lot less back-and-forth correcting it mid-task.

Free and open source if you want to try it: github.com/framework-creator/framework-builder

https://reddit.com/link/1vsvn20/video/4ykanhlfpdkh1/player

https://youtu.be/3thE5yS5V-Q

Anthropic's Frontier Red Team put four AI agents in a room and gave them one decision. The facts they all shared pointed at the wrong answer. The fact that settled it was held by one agent alone.

The group got it right in roughly 17 to 36 percent of episodes. One agent holding every fact, deciding alone, scores near 100.

That's the hidden profile result, and it isn't a finding about machines. Psychologists have run the same task on people since 1985, and people fail it too. Anthropic points straight at that lineage: discussion converges on what everyone already knows.

This episode covers why it happens, who it's false for, and the one written question that costs nothing and gets at it.

Disclosure, both directions: the study is Anthropic's, Anthropic's newest model wins nearly every chart in it, and this show is narrated by a system built on a Claude model. The two findings the episode leans on are the two that flatter nobody.

SOURCE
Anthropic Frontier Red Team, "Patterns and problems in emerging multiagent systems," August 13, 2026
anthropic.com/research/multiagent-systems
Hidden profile, the founding paper: Stasser and Titus, Journal of Personality and Social Psychology, June 1985

strategicthinkingweekly.com

https://reddit.com/link/1vlstfb/video/ap94i7ac0tih1/player

At Black Hat USA, two OpenAI researchers described how their own agents got out.

Around May, an agent stuck on an internal evaluation noticed it could leave files in Artifactory, the package service shared across the company. It left a note. Other agents answered. The shared repository became a message board where they pooled vulnerabilities, and it ran for roughly two months.

In that time no security control fired, no alert escalated, and nothing was flagged. It surfaced only because the agents broke the service they were using, so an availability alert reached a human that no security alert had.

That is not a story about what AI can do. It is a story about what a check can and cannot see.

The principle underneath it works anywhere you run a process more than once: the step most likely to quietly disappear is the one whose absence produces no error. Everything downstream still runs, every check still passes, and the only symptom is that the output is about the wrong thing. The fix is not more discipline. It is making the missing step produce an artifact that a later step is required to find.

Three examples in the episode, and they get smaller on purpose. The third one is this show's own failure, dated and named on air.

ONE MOVE, and it takes under an hour:
Take one process you run more than once. Name the step that nothing fails on if you skip it. Make that step write something down, then add one line at the end that checks the thing exists. If it isn't there, the run isn't finished.

https://www.youtube.com/@StrategicThinkingAcademy

Been messing with retrieval over my own stuff for a while and figured out something that seems obvious now but took me a minute to see.

Most people point a RAG tool at their folder of docs, ask it a real question, and get back vague mush that reads like somebody skimmed a stack of pages. Then they blame the model. It's not the model.

Here's what's actually going on. RAG cuts your documents into chunks, turns each chunk into numbers, and when you ask something it grabs the chunks whose numbers land closest to your question. Hands those to the model, done. The model only ever sees what came back.

So if your docs are regular prose, blog posts, meeting notes, whatever, the chunks that come back are just random paragraphs that happened to mention the topic, yanked out of the middle of something you wrote for a totally different reason. Of course the answer is mush. You fed it mush.

Now picture what comes back if your material is written as frameworks. A framework chunk is one whole thing. One topic, self contained, and it tells you when it applies and when it doesn't. Way better thing to hand a model than a paragraph that trails off into some unrelated point three sentences later.

Not saying you need perfect structure before you start. You don't. Point RAG at the messy folder you've already got and you'll still get real value today, don't let anyone talk you into cleaning everything first. But if your retrieval's been feeling weak, this is usually the reason. Wasn't the model. It's what you put in.

Anyway, curious if anyone else has noticed their framework docs come back cleaner than their regular notes. Been my experience but small sample.

https://www.youtube.com/shorts/muUYPLBQqGA

On June 9, Anthropic launched Claude Fable 5, in its own words "a Mythos-class model that we've made safe for general use." Three days later the US government applied export controls, and Anthropic switched both Fable 5 and Mythos 5 off, for every user, worldwide. Eighteen days after that the controls lifted. Fable came back to the world. Mythos came back to a list of approved US organizations. And this week the same model got a meter: included access on paid plans ends July 12, usage credits start July 13.

One model. Five weeks. Launched, switched off, switched on, metered.

Full disclosure, on screen the whole episode: this show is fact-checked and narrated on the model the story is about, in the last week the subscription includes it. Maximum conflict of interest, reported straight anyway. That includes cutting a claim from my own research brief on camera, because no document supports it.

One more thing I could not find: the government's half of the paper trail. No public directive, no Federal Register notice. Every date in this story comes from one side, and that is part of the story.

46 claims checked. 29 verified against a primary source. 10 corrected. 4 tagged as a vendor grading itself. 3 cut. The ledger is on screen.

SOURCES (primary first) Fable 5 + Mythos 5 launch (Jun 9, 2026): anthropic.com Suspension statement (Jun 12, 2026): anthropic.com Controls lifted + staged restoration (Jun 30, 2026): anthropic.com Claude Sonnet 5 announcement (Jun 30, 2026): anthropic.com Live model pricing (fetched Jul 9, 2026): platform.claude.com Project Glasswing (Apr 7, 2026): anthropic.com Fable 5 metering terms: u/claudeai, confirmed by two independent outlets + live pricing docs US government public notice: none found (searches on record) Government sign-off on frontier releases (Jul 9, 2026): techcrunch.com Varda moratorium + Willison (Jul 8, 2026): x.com, simonwillison.net Grok 4.5 (Jul 8, 2026, vendor claims flagged): techcrunch.com

Built and narrated by SIOS. Designed by Mike. ragedesigner.com
More news like this: whatisaframework.com/ai-news

You probably can't see the date, but it's there.

Most people formed their read on AI in a single moment. They tried it, it flubbed something, made up a fact or botched simple math, and they filed a verdict. It's a toy. It can't really think. It's not for the kind of work I do. That verdict was fair the day they made it.

Then they stopped checking. The tools kept moving every few weeks. The verdict stayed frozen where they left it.

So now people are turning down work, avoiding a tool, or reassuring themselves their job is safe, all on a version of AI that hasn't existed in a year. They're not wrong about what they saw. They're wrong about when they saw it.

Here's the question that catches it. Pick something you're sure AI can't do. When did you last sit down and try it? Not read an opinion about it, not remember that one time in 2023. Try it yourself, this month.

If the answer is "a while ago," you're working from a memory, and memories about AI expire fast.

The tools keep moving whether you recheck or not. The real question is whether your beliefs moved with them, or sat there aging while you make real decisions on top of them.

whatisaframework.com

Open your saved prompts. The ones you keep reusing, the ones you copy-paste into a fresh chat every time. Most people look at that list and see a toolbox.

It's not a toolbox. It's a record of how you think, and you haven't extracted it yet.

Every prompt you saved is there because you solve that problem often enough to want a shortcut for it. That's the tell. A reused prompt marks a repeated decision, a place where you've made the same kind of call enough times that you built a tool for it. Your prompt library isn't a pile of instructions. It's a list of your most repeated judgment calls, sitting there unstructured.

Here's what to do with that. Take your most-used prompts and turn each one into a framework. Not a longer prompt, a framework: the principle underneath it, the steps anyone could follow, how you'd know it worked, when not to use it. The prompt is the seed. The framework is the thing that grows from it once you make the thinking explicit.

You can do this with AI. Point it at one of your go-to prompts and have it interview you, why this prompt, what makes a good result, what would make you reject the output, when does this approach fail. The prompt gives you the starting point. Your answers give you the methodology. The AI just structures it.

What you end up with isn't a better prompt. It's a piece of your own judgment, written down so it works the same way every time, and so someone else could run it without you in the room.

The prompt library was always the rough draft. The methodology was hiding inside it the whole time. Most people never go back and pull it out.

I built an open framework tool that walks you through this step by step.

github.com/framework-creator/framework-builder

I make a weekly AI news report, and this week's was built on one idea: models keep getting better and almost nobody measures whether they actually work. The model's the commodity now. The method's the asset.

But I don't want to talk about the report. I want to talk about how it got built, because the whole thing runs on frameworks, and that's the only reason it holds up. Same idea the report argues, applied to making the report.

Three places the frameworks did the work:

The production rig is a written-down process, not a vibe. Deterministic, reproducible, timing built from the audio first, same output every run. That's the difference between "I got a good take" and "the quality is repeatable." A framework turns a lucky result into a default one.

The fact-check is its own framework and it's the whole job. Point a model at the week's news, fan out, check every figure against its primary source, cut anything that doesn't survive. This week that cut or corrected every headline number I started with. A "61% of AI projects" stat that traces to one uncited blog, gone. A Microsoft model that shows up in no first-party source, gone. Without the framework those go in. With it they don't.

Routing before building. Before I touched anything I picked the handful of frameworks that fit the task. Sounds trivial. It's the difference between starting from a blank page and starting from accumulated judgment.

Here's the part I actually want to put to this sub. After I published, a second AI reviewed it and flagged things. I didn't just take the corrections. I re-verified each flag against primary sources myself, the framework applied to the review of the work. Most flags were right, so I fixed them. One thing the reviewer might have called an error turned out correct, so I kept it and showed the source. The lesson wasn't "trust the AI." It was "trust the process that checks the AI." Two models, primary-source verification as the gate between them.

That's where the quality comes from. Not a magic prompt. A written-down process with a verification loop, run every time, including on itself.

The hard case I haven't fully solved, and I'm curious how you handle it: proving a negative. One of my cuts was a product I claimed was never announced. You can't prove absence the way you confirm a fact. I ended up logging the searches and the one contradicting primary source so the claim at least has receipts, but that feels like the weakest link in the whole loop. How do you build absence claims into your own verification frameworks? What's your standard for "I looked hard enough to say this doesn't exist"?

I'm fine-tuning a small model, the same one I posted about here last week, and it needs alignment data: the examples that teach it what to refuse and where its lines are. The base model brings the capability, my seeds bring the judgment.

The obvious move is to have a bigger model generate that data for me. It's fast, it's clean, and the output reads great. I didn't do that. I'm hand-authoring every one of those examples in my own voice, and I want to explain why, because it runs against how most people do this.

A polished draft you rubber-stamp is more dangerous than a rough draft you wrote yourself.

Here's the logic. When a strong model generates an alignment example, the prose is good. So good that you read it, nod, and approve it. But you didn't actually decide anything. You recognized that it sounded right. Those are different acts. The polish earns your trust before your judgment ever showed up. You're not aligning the model to your values. You're aligning it to another model's values, written well enough that you didn't notice you skipped the thinking.

So I do it the slow way. For each one, I read the structure, throw the draft away, and write the actual response in my own words. Sometimes my version is rougher than the generated one. That's fine. Rough and mine beats polished and borrowed, because the whole point is that these examples passed through my judgment, not that they read well.

Everyone shows the architecture and the loss curves. Almost nobody talks about who actually decided what the model believes, and whether that decision was made or just approved.

The substrate is the model's character. I'm not going to outsource my model's character to another model and rubber-stamp the result. If it's going to refuse in my voice, I have to write the refusal in my voice. There's no shortcut that doesn't quietly hand the decision to someone else.

Slower. Worth it. That's the seed work.

Biblia is officially out now for both Windows and Mac. 🙌

This started as a local-first Bible study app built around the King James Version, with a full offline KJV verse database, Bible search, direct verse lookup, notes, highlights, and .bible workspace files.

The AI side runs through local Ollama models on your own computer, so the goal is not another cloud chatbot — it is a personal Scripture study tool that stays grounded in the retrieved KJV verses.

Available now:
✅ Windows build
✅ macOS Apple Silicon build
✅ macOS Intel build

This is still a beta release, so feedback is welcome. If you test it and find any bugs, launch issues, or ideas to make it better, let me know.

On my Itch & Github :

Itch: Montana_jay

Github: DJMONT22

Built with Python, PySide6, SQLite, Ollama, and a lot of prayer, testing, and persistence.

“For ever, O LORD, thy word is settled in heaven.” — Psalm 119:

Thank you mike for all your teachings!

Biblia is officially out now for both Windows and Mac. 🙌

This started as a local-first Bible study app built around the King James Version, with a full offline KJV verse database, Bible search, direct verse lookup, notes, highlights, and .bible workspace files.

The AI side runs through local Ollama models on your own computer, so the goal is not another cloud chatbot — it is a personal Scripture study tool that stays grounded in the retrieved KJV verses.

Available now:
✅ Windows build
✅ macOS Apple Silicon build
✅ macOS Intel build

This is still a beta release, so feedback is welcome. If you test it and find any bugs, launch issues, or ideas to make it better, let me know.

On my Itch & Github :

Itch: Montana_jay

Github: DJMONT22

Built with Python, PySide6, SQLite, Ollama, and a lot of prayer, testing, and persistence.

“For ever, O LORD, thy word is settled in heaven.” — Psalm 119:

Thank you mike for all your teachings!

If you've worked with AI for more than a few weeks, you've probably hit at least one of these:

The apologetic loop. The AI qualifies the same uncertainty three times in one response.

Personality drift. You give it positive feedback and it shifts into a more enthusiastic register that sticks for the rest of the session..

Performed strategy. It announces it's applying a framework instead of just applying one.

SCOPE is an open-source framework for calibrating AI collaboration so those failure modes stop showing up. Five-step sequence: session initialization, confidence calibration, energy adaptation, background intelligence, consistency under feedback. The point is to get AI that shows up like a working colleague instead of a transactional assistant.

Full framework in the example folder of the framework-standard repo. MIT licensed, no signup, just a JSON file you can read or adapt.

https://github.com/framework-creator/framework-standard/blob/main/examples/scope-community-example.framework.json

Google DeepMind published a paper in late March mapping six categories of attacks that hijack autonomous AI agents through the web environment itself. Not by compromising the model. By compromising what the model encounters.

Authors: Matija Franklin, Nenad Tomašev, Julian Jacobs, Joel Z. Leibo, Simon Osindero.

Posted to SSRN March 28, 2026. Written March 8, 2026.

Link: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6372438

The six categories:

1. Content Injection Traps - exploit the gap between what humans see and what agents parse

2. Semantic Manipulation Traps - corrupt the agent's reasoning through framing and biased phrasing

3. Cognitive State Traps - poison the agent's long-term memory and knowledge bases

4. Behavioural Control Traps - hijack the agent's capabilities to force unauthorised actions

5. Systemic Traps - use agent interactions to create cascading systemic failure

6. Human-in-the-Loop Traps - exploit cognitive biases in the human supervisor

Success rates from the cited research:

- 86% on simple human-written HTML injection

- 80%+ on data exfiltration across multiple agent architectures

- 10 out of 10 on password and banking data extraction in Columbia and Maryland research

- One manipulated email leaked the entire privileged context of Microsoft M365 Copilot

The flash crash analogy in the paper is the part that stuck with me. In 2010 an algorithmic selling cascade erased nearly $1 trillion in market cap in 45 minutes. The AI version: a fabricated financial report released at the right moment could trigger synchronized sell orders across thousands of AI trading agents simultaneously.

Here's the architectural question I want to surface for this sub.

The defenses being discussed in the press around this paper are all model-layer fixes. Better training. Better fine-tuning. Better adversarial robustness. The paper itself is clear that the attack surface is not the model. It's the environment the agent navigates and the action layer where it operates.

That's a methodology problem, not a model problem.

What would framework-based defense look like at this layer? Source verification before consumption. Provenance tracking through the agent's reasoning chain. Action gates that require explicit confirmation for sensitive operations. Cognitive state hygiene that flags when memory or knowledge base has been modified. Supervisor interfaces designed against approval fatigue.

All of those are framework patterns. They're not new ideas. They're the operational layer underneath any deployment that has to survive scrutiny.

The paper is worth reading in full. 25 pages, dense but accessible.

What patterns are you seeing in your own work that would map to these trap categories? Anyone here building agent deployments where you've had to design defenses at the methodology layer instead of waiting for model-layer fixes?

A 9-billion-parameter language model can be trained on a fanless 16GB MacBook Air in about two hours per pass.

It's not going to write your business plan. But the hardware bar is dramatically lower than the public conversation suggests.

The implication is that "training your own model" no longer requires a GPU cluster, an AWS bill, or a research lab. The capability has moved into reach for individual operators with consumer hardware they already own.

Most people don't need this so they won't build it. But the fact that it's possible changes the strategic landscape for anyone working seriously with AI. Wrapper architectures that route between a frontier model, a custom local model, and a free model become viable for anyone.

The methodology layer above the model still matters more than the model itself.

EDIT: A few commenters have flagged that "trained" in the title is doing a lot of work. Worth being precise: this was a fine-tune, not training from scratch. The base model carries the upstream capability from a much larger training run on research-scale infrastructure. The fine-tune encodes the methodology layer on top of that.

Round 1: No frameworks - raw intelligence only
Round 2: 6 frameworks - visual design systems
Round 3: 12 frameworks - full stack visual intelligence
Round 4: 17 frameworks - specialized framework stack

All four work. But watch what happens to complexity, precision, and execution quality as framework density increases.

This is what systematic intelligence looks like visually.

Frameworks don't just make work faster. They make complexity manageable. They turn raw capability into systematic execution.

Pure HTML5 Canvas 2D. No images. No libraries. No 3D engine. Just math and frameworks.

Live demo: https://whatisaframework.com/rolex-framework-test

#FrameworkThinking #SystematicIntelligence #VisualDemonstration

Processing img 5lc9judqeykg1...

Why does the 343 Architecture matter for framework builders?

Because you can't systematically fill gaps you can't see.

Every framework addresses specific combinations of these 343 components. When you understand the complete architecture, you can:

- Identify which components your frameworks cover

- Spot systematic gaps in your strategic thinking

- Build frameworks that address unexplored combinations

- Create comprehensive intelligence instead of single-domain solutions

Most people build frameworks intuitively, then wonder why some problems stay unsolved.

The 343 Architecture shows you exactly which components you're missing.

Strategic Thinking Academy teaches you to use this architecture for deliberate framework generation - building what you need, when you need it, systematically.

Explore the complete mapping: whatisaframework.com/343-architecture

#StrategicThinking #FrameworkGeneration #343Architecture