OpenAI's Astra Solved Ten Open Math Problems for $2,000, ChatGPT Health Went Live for Every US Adult, and a 3x-Cheaper Video Model Shipped in a Week

Three releases from the last two weeks point in the same direction from different angles: reasoning models are starting to produce work that checks itself, chat products are learning to wall off sensitive domains instead of pretending one memory store fits every use case, and multimodal generation keeps getting cheap enough to bolt onto a chat interface without a pricing conversation. None of these are benchmark bumps — they're architecture decisions other teams just made in public. Here's what happened, and what's worth checking against your own stack.

1. A Model Solved Ten Open Math Problems and Proved It Without Asking You to Trust It

On August 1, OpenAI announced that an internal version of its next model, Astra, solved ten problems in mathematics and theoretical computer science that had been open for at least a decade — including a construction proving non-sofic groups exist, improved sphere-packing bounds, and a superexponential lower bound for multicolor Ramsey numbers that resolves a specific Erdős problem. The notable part isn't the difficulty ranking, it's the receipts: OpenAI published a 249-page manuscript alongside machine-checkable Lean 4 certificates for every result, and the GitHub repository reports a "sorry" count of zero — meaning no step in any proof was left unverified or asserted on faith. Total compute cost for all ten solutions was roughly $2,000 at API rates.

The detail worth sitting with is the "sorry" count, not the price tag. A model claiming it solved a hard problem is a benchmark score; a model producing an artifact a separate, deterministic proof checker can verify independently is a different category of trust — the output doesn't ask you to believe the model, it asks you to run a checker. That pattern generalizes past pure math: anywhere your pipeline currently accepts a model's claim at face value, the question worth asking is whether there's a cheap, independent verifier you could be running instead.

const modelClaim = {
  output: 'proof of theorem X',
  trustMechanism: 'ask the model if it's confident', // status quo for most LLM outputs
};
const verifiedClaim = {
  output: 'proof of theorem X',
  trustMechanism: 'independent checker returns pass/fail', // what Astra shipped
};
// The gap between these two isn't model quality — it's whether an
// artifact exists that something other than the model can grade.

If your system has a step where "the model says it's done" is the only signal you have, this is a reasonable week to ask whether a cheap deterministic check — a linter, a schema validator, a unit test, a second model doing pure verification — could replace that trust with a pass/fail.

2. ChatGPT Health Went Live for Every US Adult — and Kept Its Memory in a Different Room

OpenAI made ChatGPT Health available to all US-based users 18 and older across every plan, expanding from the narrower rollout it started with in July. The feature lets users connect Apple Health and supported medical records — including from US hospital systems, One Medical, or Function Health — so ChatGPT can pull medications, lab results, recent visits, and activity data into a conversation. OpenAI says it worked with more than 260 physicians on safety and escalation behavior. The architectural choice is the part worth noting for builders: health conversations, connected data, and uploaded files live in a sandboxed environment separate from the rest of ChatGPT, with their own memory store, so information shared in a health conversation isn't supposed to feed back into a user's regular chat history.

This is a bet that a single shared memory store — the default architecture for most consumer chat products — doesn't hold up once a product spans domains with different sensitivity, retention, and disclosure requirements. A grocery-list request and a lab-result conversation have no business sharing a context window, let alone a long-term memory index that later conversations can silently draw from.

// Single shared memory: simplest to build, wrong once domains diverge
const memory = { store: 'global', scope: 'all-conversations' };

// Domain-isolated memory: what ChatGPT Health shipped
const healthMemory = { store: 'health-sandbox', scope: 'health-conversations-only' };
const generalMemory = { store: 'global', scope: 'general-conversations' };
// A user's medication list should never be retrievable context
// for "help me plan a birthday party."

If your chatbot handles more than one kind of data — support tickets and HR questions, code and legal advice, anything regulated alongside anything casual — a single memory index across all of it is a liability that gets easier to justify keeping and harder to unwind the longer it sits in production.

3. Multimodal Generation Got Cheap Enough to Stop Being a Feature Decision

MiniMax released H3 on July 31: an omni-modal generation model that takes text, image, video, and audio as unified input and returns 15-second, 2K video clips with native stereo audio. It ranks #1 in Video Editing and #2 in Text-to-Video on the independent Artificial Analysis leaderboard. API pricing landed at $0.13 per second — a full 15-second 2K clip runs about $1.95, roughly a third of what comparable incumbent video models charge, with open weights promised under a community license in the days following launch.

The part that matters for chat products isn't the video quality, it's that reference-driven generation — steering a result with up to nine reference images, three reference videos, and three reference audio clips — is now a first-class capability rather than a separate tool you'd bolt on. When multimodal generation is both this cheap and this composable, "should our chat interface support rich media generation" stops being a build-vs-buy roadmap decision and starts being closer to a pricing-tier decision.

// Worth re-checking whenever a multimodal model this much cheaper ships
const mediaGenCost = {
  perClip15s2K: 1.95, // MiniMax H3, down roughly 3x from prior incumbents
  integrationEffort: 'API call with reference inputs',
};
// A feature that used to need a dedicated video-gen vendor
// relationship may now clear the bar as a line item in your
// existing model router.

What This Means for Builders

None of this week's three stories is really about a leaderboard. Astra's zero-"sorry" proofs are a template for replacing "trust the model" with "run the checker" anywhere your pipeline currently can't tell a confident wrong answer from a right one. ChatGPT Health's sandboxed memory store is an admission that one memory index doesn't serve every domain a chat product touches, and a pattern worth stealing before a regulator makes you. And MiniMax H3's pricing says the cost floor under multimodal generation keeps dropping fast enough that "not yet" is a decision with a shrinking shelf life. Check your own stack against whichever of the three actually touches what you're shipping.

— Maya