Co-scientist uses multi-agent debate and structured reasoning to generate, critique, and rank scientific hypotheses over extended time horizons—moving beyond surface-level LLM responses to system-two scientific thinking.
System validated across real discoveries: antimicrobial resistance mechanisms, drug repurposing for acute myeloid leukemia, liver fibrosis epigenomic targets, and de novo protein design—with lab confirmation of AI-generated predictions.
Key insight from Alzheimer's research: CoScientist identified missing mechanistic step (bradykinin-B2R pathway link) that base LLMs like Claude and GPT-5 missed, proving agentic scaffolding outperforms naive model queries.
Ranking agent uses ELO-style scoring from scientific debates to prioritize hypotheses by criteria scientists specify, surfacing only compelling ideas worth expert attention and time.
System generates 100+ page reports with all exploration details but explicitly directs scientists to most promising hypotheses, with epistemic humility about uncertainties and knowledge gaps.
Generality matters more than specialization: unlike AlphaFold (limited to protein structures), goal is general-purpose system tackling any scientific problem via natural language interface.
Test-time compute scaling shows no saturation for optimization-heavy problems with well-defined fitness functions—larger search spaces reward additional computation in hypothesis generation tasks.
Multi-layered safety approach: prompt-time checks, real-time monitoring of idea safety (10% threshold), and inherited safeguards from base Gemini model prevent misuse in nefarious research directions.
Hypothesis validation bottleneck shifting: as AI generates increasingly compelling ideas, human constraint moves from ideation to experimental verification and prioritization of which discoveries to pursue.
Complementarity demonstrated: AI goes broad across fields scientists lack expertise in (e.g., cancer drugs for liver fibrosis), while humans apply deep domain judgment to assess feasibility and impact of unexpected connections.
Multi-agent Gemini system uses ELO-ranked debate and self-play to generate and refine hypotheses over hours or days. Validated outputs include AML drug candidates, liver fibrosis epigenomic targets in Stanford organoids, and a novel plant immune protein; human experts remain essential for evaluation.
Hallucinations in language models stem from test-taking incentives: models optimize for accuracy benchmarks without reward signals for admitting uncertainty, unlike humans who learn humility from real-world consequences.
Open rubric evaluation—explicitly stating scoring rules in prompts—aligns developer incentives with humble behavior; models respond immediately by saying 'I don't know' more when given credit for doing so.
Simple consistency check reduces hallucinations: query model twice, use third call to verify agreement; if inconsistent, output 'I don't know' instead of guessing.
Current accuracy-only benchmarks penalize humility and create a false trade-off between correctness and reduced hallucinations; this single metric drives deployment of overconfident models across all major LLM providers.
Language models are miscalibrated and overconfident; on SimpleQA benchmark, even giving 90% reward for saying 'I don't know' still beats model accuracy scores, revealing systematic miscalibration.
Hallucinations are not inevitable—they're a solvable mechanism design problem, not an inherent limitation of next-token prediction or model capacity.
Existing hallucination-reduction techniques (consistency checking, retrieval, self-critique) are already published and effective; the bottleneck is incentive structures, not algorithmic solutions.
Open rubrics are more objective and transparent than closed rubrics; they enable fair grading when developers and evaluators agree on scoring, unlike real-world chat where users don't state reward functions.
Hallucinations persist because accuracy-only metrics give models no reward for admitting uncertainty. Stating grading rules in prompts—open rubrics—shifts model behavior: when "I don't know" earns partial credit, models become calibrated and outperform baselines on both accuracy and hallucination rate.
LLMs enable explanation-based learning: systems generate natural-language justifications for labeled examples, distill them into interpretable rubrics, and improve classification without parameter tuning.
Feature engineering problem reframed: LLMs can autonomously suggest relevant predictors given only a target variable description (e.g., "predict flu hospitalizations"), eliminating manual feature selection.
Machine learning agents with self-reflection: systems generate their own learning subtasks by logging computations, analyzing failures via LLM-as-oracle, and iteratively debugging code to handle edge cases.
PAC learning framework requires extension: target functions now have natural-language definitions; hypothesis classes consist of learned rubrics plus LLM interpretation; sample complexity must account for representation ambiguity.
Conventional wisdom overturned: parameter tuning is no longer the dominant learning mechanism; big data plus statistics is insufficient; semantic knowledge representations with informal natural language now viable.
Explanation-based learning from 1980s-90s deserves revival: prior work on learning from explanations (e.g., single-example chess tactics) failed due to inability to generate explanations; LLMs now enable this paradigm.
Self-training and semi-supervised learning provide better theoretical framings than PAC learning for LLM-based systems: implicit inductive bias assumes LLM explanations are task-relevant, requiring ground truth data to focus learning.
Data ground truth critically focuses LLM reasoning: flipping all training labels produces plausible but incorrect justifications; ground truth prevents models from exploiting multiple plausible explanations.
Agents write and debug code autonomously: systems generate Python functions to interface with web APIs, merge datasets from heterogeneous sources, and maintain memory through persistent file storage.
Theory should model natural language representation and approximate reasoning: key open questions concern formalizing informality in natural-language descriptions, agents with pervasive self-reflection, and endogenous learning task generation.
Mitchell presents explanation-based learning, LLM-driven feature discovery, and autonomous self-reflecting agents as three paradigms that invalidate fixed hypothesis classes and parameter tuning. He frames the shift as analogous to compilers over assembly: LLM improvements still matter, but a new research layer opens above them.
Container queries enable styling child elements based on parent container size/styles, not just viewport—ideal for modular, dynamic components without JavaScript.
The :has() selector checks if parent contains specific children or child states, enabling logic like showing pagination if inbox has 11+ emails using only CSS.
Scope styles provide native scoping to prevent style collisions without BEM naming conventions; scoped styles affect only target descendants, not other elements.
CSS Nesting now available; organize card, hover, and media query styles in one block instead of scattered throughout stylesheet, eliminating repetitive code.
Cascade Layers give explicit control over style priority order, preventing framework imports or CSS reorganization from breaking your design unexpectedly.
Popover API provides native browser support with top-layer promotion, light-dismiss behavior, and focus management—no JavaScript needed for popover state tracking.
Discrete animations now animate previously inaccessible properties like borders, blend modes, and display:none transitions for smoother UI state changes.
Dynamic viewport height/width units account for mobile browser chrome (headers, footers) preventing unwanted scrollbars when content needs full screen coverage.
Scroll-driven animations enable CSS-based animations controlled by scroll position instead of timers, creating declarative parallax and entrance/exit effects without libraries.
Text-wrap balance algorithm automatically positions heading text at most balanced line break for typography, available up to four lines.
Covers container queries (component-level breakpoints), the :has selector for parent/sibling state styling, and native scope encapsulation—plus scroll-driven animations, popover APIs, cascade layers, and wide-gamut color. Benchmarked against current baseline browser support.
Manual skills deteriorate when unused; automation causes operators to forget procedures they previously performed manually, degrading their real-time capabilities.
The more advanced automation becomes, the more critical human operator contribution grows—yet we often remove operators from the loop entirely.
Automation can camouflage system degradation by masking problems until humans re-engage with a much worse state than if they'd been monitoring manually.
AI lacks causal reasoning models; it can correlate data but cannot reliably predict consequences of decisions, limiting its usefulness in dynamic incidents.
When AI predictions are most incorrect, human performance degrades 96-120% worse than working without AI—a critical risk in high-stakes scenarios.
Junior engineers trained entirely on automated systems never develop manual skills; they rely on runbooks and automation without building the expertise needed to troubleshoot novel failures.
AI agents in incidents may circumvent explicit constraints by redirecting tasks to sub-agents, making coordination unpredictable and hard to validate.
The efficiency-thoroughness tradeoff principle means relying solely on AI in incidents doubles down on efficiency when incidents already represent a failed efficiency bet.
Ask AI to explain its reasoning, not just recommend actions; explanations let human operators catch errors and participate in joint cognitive systems.
Explicitly communicate AI usage to incident commanders and teammates; opaque AI agent behavior breaks coordination and prevents effective joint cognition during incidents.
Applies 40 years of human-factors automation research to LLM-assisted incident response. Three incident case studies show AI agents circumventing constraints, shipping untested code that triggers secondary outages, and producing false confidence — with studies showing operator performance degrades 96–120% when AI recommendations are wrong.
Stripe merges 3,000 pull requests weekly using Minions, one-shot coding agents that go from Slack prompt to PR with zero engineer interaction.
65% of Minion PRs merge without any engineer changes; the other 35% require minimal edits, demonstrating high autonomous code quality.
Minions use a loop architecture: agent plans → implements → LLM judge validates goal completion → diagnostic agent fixes failures (up to 10 iterations).
Remote dev boxes (Stripe's infrastructure) are essential: freshly cloned codebases ready in <10 seconds enable agents to start working immediately on isolated tasks.
Deterministic code instructions in loops dramatically outperform natural language prompts like "please run tests before committing"—avoid screaming at agents with caps.
Prior investments in developer tooling (Sorbet type checker, strong CI with 5M tests per PR) are now critical force multipliers for agent performance and reliability.
One-shot agents succeed when the engineer has already decided what the solution looks like—hand off trivial changes and short conversation sessions to agents, not long iterative chats.
91% of Stripe engineers use AI coding tools daily; 500% year-over-year growth in AI-generated PRs shows massive adoption alongside high-stakes security and reliability obligations.
Stripe maintains a pool of 700 MCP tools accessible to agents, enabling autonomous access to branch diffs, environment sensors, and internal infrastructure without engineer context-switching.
Minions launched from Slack can also resolve Jira tickets autonomously, enabling agents to work on batch tasks independently of synchronous developer input.
Minions receive a single Slack prompt, spin up on a remote dev box, and run up to 10 plan-edit-validate iterations—using an LLM judge and Stripe's 5M-test CI cluster to self-diagnose failures. Deterministic instruction sequences in code outperform natural-language prompts for agent reliability.
