The OpenAI Board Member Who Fired Sam Altman Says We Still Can't Trust AI CEOs — Builder Notes
Helen Toner's appearance on The Verge's AI-in-real-life series is worth an hour of your team's time, but not for the gossip. Toner — executive director of Georgetown's Center for Security and Emerging Technology, and one of the OpenAI board members who voted to remove Sam Altman in November 2023 — is describing a governance failure, and governance failures in AI labs propagate straight into your dependency graph. If a frontier lab's leadership can't be relied on to give its own board straight answers, the same leadership's model cards, safety commitments, and deprecation emails deserve exactly the same scrutiny you'd give any other vendor's marketing.
The structural point matters more than the personality: frontier AI labs face commercial pressure to ship, to hype capability to investors, and to downplay risk to regulators — sometimes in the same week. Voluntary commitments are not controls. For teams building on top of these models, that means trust has to be a runtime property you can verify, not a press release you can cite.

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: www.theverge.com
What the interview actually claims
Strip out the news cycle and Toner's argument reduces to a few engineering-relevant claims:
- Concentration of authority is the risk. A single leader with outsized control over information flow and roadmap is a single point of failure for safety decisions. Boards that can't get candid answers can't govern.
- Voluntary safety pledges aren't enforceable. Companies change leadership, priorities, and policies. Contracts and external oversight survive those changes; blog posts don't.
- Incentives diverge between labs and their customers. A lab is optimizing for adoption, capability, and valuation. You are optimizing for your users, your uptime, and your liability. Those aren't the same objective function, and when they diverge, you lose.
None of this requires believing any specific lab is acting in bad faith. It only requires accepting that you cannot audit what you cannot see.
Architecture: put the trust boundary where you can enforce it
The most common mistake in LLM-integrated systems is treating the provider as part of the trusted computing base. It isn't. It's a third-party SaaS dependency with a probabilistic API and a release cadence you don't control.
Provider abstraction is not over-engineering. A thin interface — generate(), embed(), classify() — with one adapter per vendor buys you three things: the ability to fail over during an outage, the ability to move a workload when pricing or terms change, and the ability to A/B a model without rewriting call sites. The teams that skipped this in 2023–2024 spent weeks on migrations that should have been config changes.
Pin versions explicitly. Register model IDs with dates and treat them like container digests. Silent point releases have changed refusal behavior, JSON-mode reliability, and tokenization in ways that broke downstream parsers. If the vendor doesn't offer a stable alias with a deprecation window, that's a procurement finding, not a nuisance.
Evals belong in CI. Golden sets per feature, scored on every prompt change and every model bump, with a threshold that fails the build. The eval suite is your only defense against the "it looked fine in the demo" class of regression, and it's the artifact that lets you push back on leadership pressure with evidence instead of vibes.
Map what leaves your boundary. One diagram, one data-classification column per field: what's sent to the provider, what's retained, what's logged, what's used for training. If nobody can produce that diagram, you have an unassessed data-egress path.
Ops: detect drift before users do
Model behavior drifts even when nothing on your side changed — provider updates, upstream routing changes, load-dependent latency, prompt caching quirks.
- Log richly, retain deliberately. Request ID, model version, prompt template hash, temperature, token counts, latency, truncated response. Don't log raw user content by default; where you must, scope retention and access.
- Run synthetic monitors. A small set of fixed prompts with expected properties, executed on a schedule, alerting on behavior change. Cheap, and it catches provider-side regressions hours before support tickets do.
- Make prompt and model versions deployable artifacts. Feature-flagged, rollback-able, reviewed like code. Prompt changes in a database console with no audit trail are how you get unexplainable incidents.
- Write the runbook for "the model is behaving badly." Who can disable the feature? What's the fallback — retrieval-only, template response, human queue? What's the customer communication? Decide now, not at 2 a.m.
- Bound agent loops. Max steps, max tokens, max wall-clock, max spend per request and per tenant. Unbounded agents are unbounded bills.

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: www.theverge.com
Security: prompt injection is an authorization problem
Treat model output as untrusted input, because it is — it's attacker-influenced text flowing into your system. The moment a model can call tools, "ignore previous instructions" becomes privilege escalation.
- Scope every tool. A tool that reads email should not also be able to send it. Per-tool allowlists, per-tenant credentials, explicit egress allowlists for any tool with network access.
- Human confirmation for irreversible actions. Payments, deletions, external sends, permission changes. The model proposes; a human or a hard-coded policy disposes.
- Enforce authorization at query time in RAG. Filter by the requesting user's ACLs at retrieval, not at index time, and not by asking the model to "only use documents the user can see." Multi-tenant vector stores with a shared collection are a cross-tenant data leak waiting for a bad embedding query.
- Vet the whole supply chain. SDKs, plugins, community tool connectors, MCP servers — every one is code with your credentials in scope. Pin them, review them, and don't let the model install more.
- Get data-handling answers in writing. Retention windows, training use, subprocessors, regional processing. If the vendor can't answer contractually, model the worst case and classify the data accordingly.
Delivery and procurement: the questions that actually matter
Procurement is where you convert "we trust them" into "we can verify them."
| Ask | Why it matters |
|---|---|
| Model change notification + deprecation window | You need lead time to re-run evals and migrate |
| Audit rights / security questionnaire reciprocity | Your customers will ask you, and you'll need answers |
| Data retention, training use, subprocessor list | Determines what data you can legally send |
| Breach notification timeline | Sets your own disclosure clock |
| Exit terms: export formats, prompt portability | Your migration pain is a contractual problem |
Then answer the internal version: if this provider doubled prices or vanished next quarter, how long until we're back online? If the answer is "weeks," budget for it rather than discovering it.
The uncomfortable part: this applies to your own leadership
The boardroom story is about a governance body that couldn't get candid information from the person running the organization. Most engineering orgs have a smaller-scale version of the same failure: AI features scoped by executives who've seen demos, shipped without eval coverage, with risk acceptance that lives in a Slack thread.
Toner's implicit lesson for builders is procedural, not dramatic: make disagreements legible. Eval reports, incident logs, a written risk register, documented "we are knowingly shipping without X." Written artifacts are how a team creates candor when hierarchy discourages it, and they're the only thing that survives the reorg.
A working definition of trust
Trust in a model provider isn't a feeling about a CEO. It's the set of properties you can demonstrate: we know which model versions we're running, we can detect behavior change, we can roll back in minutes, we can bound what the system is authorized to do, we can exit, and we can show our work to a customer or a regulator on a week's notice.
Everything else is a press release. Build accordingly.
Sources
- The Verge, Helen Toner on OpenAI, AI safety, and policy (podcast, part two of "AI in real life"): https://www.theverge.com/podcast/1032907/helen-toner-openai-cset-ai-safety-policy-interview
- Center for Security and Emerging Technology, Georgetown University: https://cset.georgetown.edu/
- OpenAI, board announcement and subsequent reinstatement statements: https://openai.com/blog
- NIST AI Risk Management Framework (governance and risk-register scaffolding): https://www.nist.gov/itl/ai-risk-management-framework
- OWASP Top 10 for LLM Applications (prompt injection, excessive agency, supply chain): https://owasp.org/www-project-top-10-for-large-language-model-applications/



