Anthropic shipped the best coding model measured, then the government pulled it

Let me start with a number because it’s the one that organized my whole week, 91 out of 100. That’s the score Claude Fable 5 put up on the team at Every’s internal senior engineer benchmark, the test they use to gauge whether a model can actually do the work of a human senior engineer. 8 at 63. GPT-5.5 sat at 62.

So this wasn’t an incremental bump, it was a model clearing a bar that the entire previous generation of frontier systems had been bouncing off of. And here’s the part that makes it the story of the week instead of just a good launch. Four days after Anthropic shipped it, the US government took it off the market. By June 12, Claude Fable 5 was gone from Devin, gone from Augment Code, restricted inside Microsoft, pulled under an export directive.

Frontier capability to regulatory suspension, inside a single week. That arc is what I want to walk through, because it reframes it. It reframes basically everything else happening in the field right now. So let’s start with what Fable actually is because the naming is doing some work here.

Anthropic released two models on June 9, Claude Fable 5 and Claude Mythos 5. They’re the same underlying model. The difference is that Fable has a layer of safety classifiers bolted on and Mythos doesn’t. Anthropic’s own framing is that Mythos 5 shares Fable 5’s capabilities without the safety classifiers.

And Mythos went out the same day but only to a small preview group. Fable is the version meant for public general release, the one you could actually go use on Oz or in Claude Code. So when you hear people talk about a Mythos class model being made safe for the public, that’s the split they’re describing. Same weights, same raw capability, one of them wearing a seat belt.

The specs tell you this is a scale jump and not a tuning pass. A 1 million token context window, 128,000 maximum output tokens, a knowledge cutoff of January 2026, and the pricing which is the tell, $10 per million input tokens, $50 per million output tokens. 8 on both sides. When a lab doubles the price, they’re telling you something about the cost of running the thing and by extension something about its size.

And one more pricing wrinkle that the suspension made moot, Anthropic had made Fable available on the subscription plans, the $100 a month max tier and so on, for free. Until June 22nd, after which it was going to be billed as an extra. So there was this two-week window where subscribers got to hammer on a frontier model at no marginal cost, and then the government directive landed inside that window and closed it early. AWS’s launch language is worth reading closely because it’s the most concrete description anyone gave of what long horizon actually means in practice.

Their framing was that Fable 5 can run for extended periods of time, and that’s why it’s called Fable 5. The Fable 5 model has extended periods on complex knowledge work and coding tasks without intervention, and the specific behaviors they called out are the interesting part. The model proactively self-updates its own skills based on what it learns during a task. It develops its own evaluation harnesses, it writes the tests it’s going to grade itself against, and it verifies its own work before delivering it.

AWS positioned it not as a coding assistant but as something aimed at professional work across finance, legal, marketing, sales, data, and engineering. The model as an autonomous worker that builds its own scaffolding as it goes rather than a tool you steer keystroke by keystroke. Whether it fully lives up to that framing is a separate question, but that’s the ambition being sold, and it’s a meaningfully different ambition than autocomplete that’s gotten very good. There were two ways to get at it on AWS, and the distinction matters for anyone thinking about data governance.

Amazon Bedrock, which keeps your data inside AWS infrastructure, wraps the model in AWS-managed guardrails, knowledge bases, and regional data residency. And the Claude platform on AWS, operated by Anthropic directly, which gives you the native Claude experience with unified AWS billing and authentication. Same model, two trust boundaries, and given that the whole suspension turned on data retention requirements, which boundary you picked turned out to matter more than anyone expected on launch day. Simon Willison got his first job at AWS, and he was a member of the AWS team.

He was a member of the AWS team in begun micro startups, and one of the marketing leaders. And he also worked on Android and HuN, and Amazon delays digital analytics. 5 hours of poking at it, and his write up is the one I’d point you to first if you want a practitioner’s read. His headline impression was simple, this model feels big.

Not big as in slow, though it is slow, and not big as in expensive, though it’s that too. Big as in how much it knows, he ran a test I really liked for it’s simplicity. He asked the model with no search access to list all of his own open source projects, most recent first, each with a rough release date. Speaking of his reliable starts 되ents.

each with a rough release date. 8’s answer was honest but hedged, it basically said, I don’t have a reliable date verified list, here’s what I’m reasonably confident about, and gave 4 or 5 projects. Fable came back with a structured list going back 2 decades, files to prompt in 2024, Simbex in 2023, shot-scraper in 2022, sqlite-utils in 2018, data set in November 2017, all the way back to Django being open sourced in July 2005. Accurate dates, pulled from the weights, no lookups.

And Simon’s been on record for a while saying he doesn’t actually care how much a model knows, he wants models that manipulate text and code well and look up what they need through tools, not bake the whole world into their parameters. But he made an interesting concession here, which is that world knowledge density is a decent proxy for raw model size, you can only cram that many accurate details about reality into a large number of parameters. And a coding model with deep, current knowledge of libraries and patterns plausibly crunches through real coding tasks more effectively because it’s not constantly stopping to look things up. He thinks Fable might be the largest model any vendor has shipped to date.

Anthropic hasn’t said a word about parameter count, so it’s all tea leaves, the speed, the price, the knowledge, but those leaves all point the same direction. Now, the part that actually matters for your work, Simon didn’t just run trivia. His stretch goal that day was to add a real feature to Dataset Agent, the ability for tool calls inside that agent to pause mid-execution and request approval from the user, human in the loop on a running agent. That’s a meaty, fiddly task, it touches async execution, it touches how you resume a chain that’s sitting on unresolved tool calls.

Fable solved it, but it did more than solve it. It first got everything working with what Simon called gnarly hacks, and then, the most important part, the moment he told it that changes to his underlying LLM library itself were in scope, it went back and unwound those hacks into properly supported features of the library. It shipped six distinct improvements to LLM unique tool call IDs. A clean pause chain exception for pausing a tool chain to wait for human approval resumed from history semantics, a bug fix where the async executor was silently dropping calls to tools that weren’t registered.

320, which was the first time he’d done that. It was the first time he’d done that. It was the first time he’d done that. It was the first time he’d done that.

It was the first time he’d done that. It was the first time he’d done that. It was the first time he’d done that. It was the first time he’d done that.

It was the first time he’d done that. It was the first time he’d done that. It was the first time he’d done that. Almost entirely written by Fable, and his summary was that it felt like several days of work compressed into an afternoon.

42 of tokens doing it, all absorbed inside his $100 a month subscription, which tells you something about how anthropic was pricing access during the launch window. The team at EveryFrame the capability the way I keep coming back to. They called Fable a warp drive for coding, set it loose on a huge task, an overnight job, a whole production bug backlog, and it comes back with the work done one shot. They watched it clear entire bug backlogs, build a playable 3D environment, even produce a two-minute animated film, all one shot.

Two things they flagged beyond raw capability stuck with me. The first was taste. They said that in coding and knowledge work, Fable showed much better taste and attention to detail than anything they’d tested. It gets subtle things right.

It adds small features you didn’t think to ask for. It generally understands the assignment in a way that surprised them. That’s a hard thing to benchmark and an easy thing to feel, and it lines up with what Simon Willison saw when the model unwound its own hacks into proper library design without being told exactly how. The second was context use.

They pointed it at a pile of customer feedback surveys and their own website analytics, and it came back with a crisp report that identified their single biggest problem and proposed a concrete, testable solution, and then they handed that solution straight back to it to build. The model doing the analysis and then executing on its own analysis, with the human only in the loop to say, yes, go. But in this is the crucial qualifier, a warp drive is not how you get around town. It’s slow.

It’s token-hungry in a way that’s almost comical, routinely burning 500,000 to a million tokens on a single task. It runs about twice the cost of Opus. And their explicit guidance was that this is a power user tool. If you’re already orchestrating multiple agents, already thinking about how to use it, and you’re already thinking about how to use it, then you’re thinking in terms of long-horizon autonomous runs, Fable does things you have not seen before.

If your setup is a single chat window, and you’re doing collaborative writing or quick edits, you will genuinely not notice the difference, and you should not be paying for it. Their phrase was that using Fable for normal knowledge work is like squashing an ant with a rocket launcher. Even their most advanced testers said they felt like they were only scratching the surface of what it could do, which is either exciting or ominous depending on your relationship to your token-hungry client. But they were not.

They were only scratching the surface of what it could do, which is either exciting or ominous depending on your relationship to your token budget. There’s a concrete illustration of the cost curve in Simon Willison’s write-up that I think is worth saying out loud, because it’s the kind of thing you only learn by running the model yourself. He ran the same prompt, generate an SVG of a pelican riding a bicycle, which is his standard model vibe test, across all five of Fable’s thinking effort levels. At low effort it spent about 1900 output tokens, roughly 10 cents.

At max effort same exact prompt, it spent over 14,000 output tokens, about 72 cents. The same task, seven times the cost, just by turning the thinking dial up. And amusingly, high effort used fewer tokens than medium on that particular run, so the relationship isn’t even cleanly monotonic. The practical lesson is that with a model this expensive, the effort level isn’t a quality knob you set and forget, it’s a cost lever you need to actually think about per task, because the difference between low and max, that’s not a problem.

If you want to use Fable Henrietta’s on a million token job is the difference between a coffee and a car payment. There’s one more technical detail from the launch that’s going to matter going forward, which is that the safety classifiers on Fable trigger often. Often enough that Anthropic shipped new API machinery specifically to deal with refusals. There’s now a mechanism where if a request trips a safety classifier and gets rejected, the API can automatically fall back to a different model instead of just failing your call.

Think about what that implies about the refusal rate. You don’t build automatic model fallback plumbing for an edge case that fires once a week. You build it because the guardrails are aggressive enough to interrupt real workflows and you need a graceful degradation path so your production system doesn’t just throw errors when the classifier gets nervous. So that’s the launch, state-of-the-art on nearly every benchmark, a genuine step up in autonomous, long-horizon work, available generally on AWS Bedrock and the Claude platform on AWS, available in Claude.

AI and Claude code across web and CLI, added to GitLab’s Duo agent platform, the whole distribution surface lit up within hours. And then three days later, most of it went dark. InfoQ has the clearest account of the suspension. S.

government export directive. There were manhandling of the Fable 5 and the Fable 5. There were mandatory data retention requirements attached to the model, and those requirements had already been causing friction. Microsoft had restricted its own employees from using Fable 5 before the broader suspension even hit.

Then the directive came down. Cognition removed Fable from Devin. 8 at Opus pricing. Augment Code did the same thing in its Cosmos product, pulled it from the model picker, fell back to Opus.

AWS had made it generally available on Bedrock on June 9th, and for most users it was simply switched off a few days later. I want to sit on the mechanism here, not because it’s dramatic, but because it’s new. We have seen models get deprecated. We have seen models get rate limited, get price changed, get quietly rolled back because of a quality regression.

What we have not seen before is a frontier model’s distribution getting gated by export control policy in the middle of its rollout. This is the first time the government has reached into the deployment of a specific commercial model, and said, this one comes off the shelf. And it landed on exactly the teams who were most excited, the ones who’d looked at Fable’s million token window and its overnight autonomous profile and started architecting around it. If you’d spent the back half of that week building a pipeline that assumed Fable’s long horizon capability, you woke up on the 13th with your backend falling back to a model two tiers down.

That’s a new category of platform risk, and it’s worth internalizing. Model availability is now a function of policy, not just of the vendor’s roadmap. Which brings me to the strategy piece that sits right underneath this, Ben Thompson’s write-up at Stratechery, which he titled Anthropic Safety Superpower. His core argument is that Anthropic has managed to convert its safety posture from a cost into a competitive moat.

The classifiers, the retention control, the cost of the product, the cost of the product, the cost of the product, the cost of the product, the cost of the product. The refusal fallback machinery, all the apparatus that other people might see as friction, Thompson reads as the thing that lets enterprises and governments treat Claude as the defensible, grown-up choice. Safety isn’t the tax you pay to ship, it’s the reason regulated buyers pick you. And the Fable suspension is this fascinating stress test of that thesis, because it cuts both ways.

On one hand, yes, the whole Fable vs. Mythos design, ship the classified version publicly, keep the unfairness. On the other hand, the exact same retention requirements that make Fable enterprise-grade are what entangled it in policy and got it pulled. The safety apparatus is a differentiator right up until the moment the safety apparatus becomes the handle that regulators grab.

You build the most controllable frontier model on the market, and controllability turns out to mean someone other than you can decide to control it. I don’t think that invalidates Thompson’s… argument, but it adds a clause to it. Safety as a moat is real, and safety as a moat also means you’ve built the lever that can be pulled against you.

Before I move off Fable, I want to name the thing that actually made this the story of the week, which is the convergence. It’s rare that I see a single launch saturate every channel at once the way this one did, and the breadth of coverage is itself the signal. Latent Space’s AI News ran it as the lead. Nathan Lambert covered it at Interconnects, framing it around the new AI safety fables.

I don’t know if you’ve heard of Fable’s angle, that Fable vs. Mythos safety split as a deliberate research and policy posture. Elvis Saravia’s NLP newsletter folded it into AI Agents Weekly alongside the other releases of the week. Lenny’s newsletter ran a full review titled What the New Mythos Model Gets Right and Very Wrong, which is a useful tell on its own, because Lenny’s audience is product people, not just ML engineers, and the model crossed over into the product management conversation immediately.

AlphaSignal ran a piece on leaked system prompts that, per their reporting, pointed to a new mythos tier and some kind of persistent storage mechanism. It showed up on benchmarkless getting compared head-to-head against everything else within hours of launch, and then the suspension generated its own second wave of coverage, the cognition statement, the augment code statement, the InfoQ news write-up, Microsoft’s internal restriction. When a single model launch shows up in the same week across the research newsletters, the product newsletters are the ones that get the most attention. They’re the ones that get the most attention.

They’re the ones that get the most attention. They’re the ones that get the most attention. They’re the ones that get the most attention. The product newsletters, the vendor blogs, the benchmark trackers, and the policy commentary all at once, that’s the field telling you collectively that this one matters.

Most weeks, the loudest thing is loud in one or two channels. Fable was loud in all of them, and then it got pulled, which made it loud all over again. If you only track one story out of this issue, the saturation is your signal that it should be this one. Now all of this capability lands in the middle of a labor argument that just refuses to resolve, and two pieces this week took it head-on.

The one I’d say is, I’d send people to is from normal tech, titled Why AI Hasn’t Replaced Software Engineers and Won’t. It’s a long read, about 23 minutes, and the spine of the argument is that code generation was never the actual bottleneck in software engineering. The bottleneck was specification, judgment, and the accumulated context of why a system is the shape it is. And I think Fable is, weirdly, evidence for that case rather than against it.

Here’s a model that scores 91 on a senior engineer benchmark, and the single most impressive, thing it did in Simon Willison’s hands only happened because Simon told it that changes to the underlying library were in scope. Left to its own framing, it produced working hacks. Given the right specification of the problem boundary, it produced excellent library design. The judgment about what the problem actually was still came from the human.

The model’s a phenomenal executor once the problem is framed, and the framing is still the hard part. Gabriel Weinberg, the founder of DuckDuckGo, made an adjacent point in a piece called No, Everyone is Not Using AI for Everything. His argument is basically a reality check on the adoption curve. The discourse makes it sound like AI usage is universal and total, and the actual consumption data is far more concentrated and far spottier than the narrative implies.

People are consuming AI the way they consume a lot of new technology, in bursts, in specific niches, not as the ambient everything layer the hype describes. It’s a useful corrective to read in the same week a model breaks a benchmark, because it separates what’s possible at the frontier from what’s actually happening in the median workplace, and those two things are much further apart than the headlines suggest. So if the model can now run unattended overnight, the real question shifts. It’s not can the model do the task, it’s how do you wrap the model so it does the right task the right way.

And there was a genuinely useful experiment posted on the r slash llm devs subreddit this week that gets at exactly this. A developer ran three coding agent experiments on a real production code base and compared five different workflow shapes. Direct implementation where you just ask for the change. Discovery only where the agent investigates before acting.

Planning only, review only. And a full autonomous loop where you let it run unrestricted. They ran these across three tasks. Small sample, they’re upfront about that, but the result is more interesting than the sample size would suggest.

For new feature development, the discovery and review workflows consistently beat unrestricted autonomy. But for a large refactor, unrestricted autonomy won, and it won decisively. Their hypothesis for why is the part worth keeping. Artifact-driven workflows, the ones where the agent produces a discovery doc or a plan or a review, seem to win when the task can be compressed into a small context artifact.

You can capture the essence of a new feature in a short spec, hand the agent that artifact, and it executes well against a tight, clear target. But autonomous workflows win when success depends on preserving large amounts of existing code context, like a big refactor, where the whole point is that the agent has to hold the entire shape of the existing system in its head, and you can’t compress that into a one-page plan without losing the thing that matters. That’s a clean mental model for when to hand the model the wheel versus when to keep it on rails, and it scales up exactly as the models get more capable. That maps directly onto a debate that got sharper this week, which is whether you can even trust those giant context windows.

Garrett Frank wrote a piece called Don’t Trust Large Context Windows, and the argument is that a million tokens of available context is not the same as a million tokens of usable attention. You can stuff the window full, but the model’s ability to actually attend to and retrieve from the middle of that context degrades in ways that are hard to observe from the outside. Your retrieval quality drops and you don’t get an error, you just get subtly worse answers. And the counterposition showed up the same week over on r slash vibe coding, developers reporting that they’d turned off RAG entirely, stopped doing retrieval, and just started dumping their whole repository into context, because with Fable class windows it just works for their code base.

And honestly both of these can be true at once. If your repo genuinely fits inside the window the model actually attends to, dump it all in, and you can’t just dump it all in, and you can’t just dump it all in, and you can’t just dump it all in, retrieval is just overhead. If it doesn’t, you’re back to needing real retrieval and you should not trust the window to save you. The problem is nobody has a crisp number for where that line sits, where the genuinely attended window ends and the nominal window keeps going.

Until somebody does, this stays a judgment call you make per code base. Let me move to the plumbing because while the model story was exploding, the boring infrastructure kept shipping, and some of it matters more than the fireworks. The model context protocol, MCP, is not the only one that matters. The model context protocol, MCP, is not the only one that matters.

The model context protocol, MCP, is not the only one that matters. The model context threshold this week from spec demo into production security surface, and two big vendors did it independently and simultaneously. Dropbox published a detailed piece on how it uses MCP together with its Dash product to close what it calls the design-to-code security gap. The concern there is specific and real.

When an agent has tool access to your design assets and your code, how do you make sure it doesn’t leak design material through its tool calls? That’s an enterprise security problem, not a hello world, and Dropbox is solving it in production. The same week, AWS published a parallel piece on diagnosing EKS node issues faster using its DevOps agent and a custom MCP server, an Opsen debugging use case, the agent reaching into Kubernetes node state through MCP to triage problems. Two large companies the same week, treating MCP as the thing you build production security and operations on top of.

That’s the signal. MCP stopped being a thing people demo and became a thing people deploy. The same week, AWS published a parallel piece on how it uses design-to-code security and operations on top of. That’s the signal.

MCP stopped being a thing people deploy and have to secure. Motherduck pushed the agent-native idea even further with a product launch called Flights, which is data ingestion designed for agents to drive rather than humans. And I think that framing is the interesting part, more than the product itself. The assumption baked into most data tooling is that a person is at the controls, clicking through a setup, mapping fields, handling errors.

Flights inverts that, it assumes the caller is a model, and designs the ingest interface around it. Flights is a tool that can be used to build a system around what an agent needs to drive it reliably. As more of your stack gets operated by agents instead of humans, you’re going to see more of this, infrastructure where the primary user is explicitly a model, and the human is the supervisor rather than the operator. GitLab made the largest structural bet of anyone this week.

At its Transcend announcements, it repositioned the entire platform around what it’s calling the agentic engineering era. And this is the same week it added Fable 5 to the dual agent platform, before it was able to do so. Fables 5 is the same week it added Fable 5 to the dual agent platform, before it was able to do so. Fables 5 is the same week it added Fable 5 to the dual agent platform, before the suspension hit.

The thing to notice is that the incumbent CI-CD vendors are no longer bolting AI features onto a pipeline product. They’re recasting the pipeline itself as the substrate that agents run on. The pitch isn’t here’s an AI assistant for your pipeline, it’s your pipeline is now the execution environment for autonomous engineering agents. That’s a much bigger claim, and GitLab is making it as a deliberate platform repositioning, not a feature release.

And underneath all of this is a macro data point that genuinely reframes how you should think about provisioning for the web. SEMrush reported that bot traffic now exceeds human traffic. The majority of requests hitting the web are now agents, crawlers, tool callers, automated systems, not people. And once that’s true, a lot of assumptions quietly invert.

Your rate limiting was designed around human request patterns. Your SEO was designed for human readers. Your infrastructure capacity planning assumed that you’re not going to be assumed humans on the other end. If the median visitor to your service is a model, all of those need rethinking, and we’re now past the point where that’s a future hypothetical.

It’s the current composition of the traffic. That majority bot reality is exactly why the governance questions stopped being abstract this week. InfoQ published a practical guide to governing AI in the cloud aimed at architects, and the reason it’s worth your time is that it’s concrete rather than aspirational. It walks through shadow AI discovery, finding the agents and integrations people have stood up across your environment that nobody centrally approved, policy as code so your AI usage rules are enforced mechanically instead of living in a wiki nobody reads, and IAM enforcement so an agent’s permissions are actually scoped to what it’s supposed to touch.

And the fable suspension is the perfect argument for why this matters. The model got pulled partly over data retention requirements, which is a governance problem. It’s a problem that’s not just a problem for property, not a capability property. If you didn’t know which of your systems were sending data to which model under what retention terms, you found out the hard way when the directive landed.

The teams that had real governance that could answer what’s touching fable and what data is it sending, handled the suspension as a config change. The teams that didn’t had to go discover their own exposure under time pressure. Governance stopped being the compliance teams problem, and became an availability problem. I want to close on two pieces of this.

The first one is that it is a matter of time. There’s a lot of time required to be able to get the right tools to operate a system, and a lot of time requires that. It’s a matter of time. The second is that it’s a matter of time.

It’s a matter of time. There’s a lot of time required to I want to close on two pieces that argue for the durable parts of the stack, the things that hold their value while the models churn underneath them. Jane Street published a piece on formal methods and the future of programming, and the argument is one I find more compelling every month, which is that as AI generates more and more of your code, machine-checkable correctness becomes more valuable, not less. When you wrote every line yourself, you had a mental model of why it was correct.

When a model writes code that feels like several days of work in an afternoon, you did not build that mental model you can’t have, you weren’t in the loop for most of it. A formal proof, a machine-checked guarantee, is the thing that lets you trust output you didn’t personally reason through line by line. Formal methods were always valuable in the highest-stakes domains. In a world of AI-generated code, that value proposition extends a lot further down the stack, because the gap between code that runs and the value proposition extends a lot further down the stack.

The gap between code that runs and code you’ve verified is exactly the gap that AI generation widens. On the same theme of unglamorous hardening that matters more in an agentic world, GitHub disabled NPM’s autorun install scripts. This is a default change that touches every single node developer’s install behavior. For years, NPM packages could run arbitrary scripts automatically at install time, which is a well-known supply chain attack vector.

You install a package, it runs code you never looked at. GitHub pulling the pin on that default closes a long-standing arbitrary execution hole. And it matters more now specifically, because agents are starting to run NPM install unattended. When a human runs install, there’s at least a person who might notice something weird.

When an autonomous agent is churning through a build overnight, running installs as it goes, that auto-execution vector is exactly the kind of thing you want closed by default, because there’s nobody watching the specific moment it fires. Two more quickly for the builders thinking about resilience. Andrew Ng’s aisuite resurfaced this week. It’s a unified interface across LLM providers, one API surface, swap the backend underneath.

And it looks a lot more relevant in a week when a model you depend on can vanish under a government directive with three days’ notice. The lesson of the fable suspension, if you’re building on top of these models, is don’t hardwire yourself to one. The teams that had abstracted their provider layer could swap to Opus, or GPT-5.5 when Fable disappeared. The teams that had built directly against Fable’s specific behavior had a worse week.

A provider abstraction layer used to be a nice-to-have. After this week, it reads as basic operational hygiene. So where does that leave us? The capability ceiling jumped this week hard.

A model cleared a senior engineer bar that the whole previous generation couldn’t touch. And then the most interesting thing about it stopped being the capability and became the question of who controls access. Anthropic built the most controllable Frontier model on the market, and controllable turned out to mean that someone other than Anthropic could decide to pull it. The thing I’m watching now is whether Fable 5 comes back under amended terms, retention requirements renegotiated, export concerns addressed, or whether this suspension becomes the template, the first instance of a pattern where Frontier models get gated by policy mid-rollout is a matter of course.

Because if it’s the template, then the most important spec on your next model is Fable. And if your next model isn’t the context window or the benchmark score, it’s whether you’ll still be allowed to use it next week. The ceiling went up. The open question is who gets to stand on it, and for how long.