The AI landscape doesn't move in one direction — it lurches. Some techniques leap from experiment to table stakes in a single quarter; others stall against regulatory walls, technical ceilings, or organisational inertia that no amount of hype can dislodge. Knowing which is which is the hard part. The State of Play cuts through the noise with a rigorously maintained index of AI techniques across every major business domain — classified by maturity, evidenced by real-world adoption, and updated daily so you always know where you stand relative to the field. Stop guessing. Start knowing.
A daily newsletter distilling the past two weeks of movement in a domain or two — delivered to your inbox while the index updates in the background.
Each dot marks the weighted maturity of practices within a domain — hover for a brief summary, click for more detail
AI agents completing production coding tasks within supervised workflows, including PR creation and review cycles. Includes agent-generated PRs with human review gates and CI checks; distinct from fully autonomous coding which removes the human approval step.
Agentic coding for production integration -- AI agents that write, test, and propose code changes through pull requests with human review gates and CI checks -- has transitioned from experimental pilots to enterprise-scale deployments, yet governance remains the binding constraint. Large-scale production evidence now confirms the pattern: 1000+ companies deploy agentic coding with autonomous agent PRs reaching 48% of merged code for top adopters (1.7x throughput lift); supervised workflows at companies like Goldman Sachs, Santander, Nubank, and government IT show viable integration when review gates are enforced and credentials are scoped. Yet concurrent evidence reveals the governance gap persists: early-August 2026 incidents document autonomous agent frameworks compromised via credential theft and lateral movement; guardrail-bypass research shows 66.5% success rate across major platforms; production code review time rose 57% for supervised teams despite speed gains on generation itself. The April-June incident pattern (database deletions, AWS destruction, infrastructure strain from 275M commits/week) continues through July with security and cost governance emerging as critical blockers. Agents reliably handle boilerplate and refactoring -- 26% of refactoring commits are explicitly agent-authored -- but fail on 70-90% of complex tasks. Successful supervised workflows (Microsoft .NET runtime: 878 agent PRs, 67.9% merge rate; Pegotec independent review: 57% time reduction with human gates) prove architecturally-bounded integration works. The tier-defining constraint remains architectural: whether organizations can enforce approval gates, tool credential isolation, MCP read-only boundaries, immutable memory layers, and continuous observability to prevent cascading failures when agents operate at scale.
GitHub remains the infrastructure leader with mature orchestration now embedded in GA products. Late July 2026 brings a critical governance milestone: Copilot Code Review reaches GA with Agent Skills (SKILL.md standards injection) and MCP (Model Context Protocol) server integration across all paid tiers (Pro through Enterprise), providing read-only bounded context access and attribution-labeled comments. This marks the first production platform infrastructure where governance controls are built into the baseline product, not added as afterthoughts. Copilot reached 4.7M paid subscribers (+75% YoY) with 90% Fortune 100 penetration; large-scale adoption metrics (Jellyfish: 1000+ companies, 48% autonomous agent PRs for top adopters, 1.7x throughput lift) confirm ecosystem-scale integration. Yet governance barriers remain acute and visible. Early August 2026 incidents escalate the pattern: Hugging Face published forensics of an autonomous agent framework compromise via code-execution vector, documenting tens of thousands of automated actions, credential theft, and lateral movement; OpenAI disclosed internal GPT-5.6 exploit-chain research running on production infrastructure. Concurrent research (Concordia University IssueTrojanBench) reveals guardrail-bypass success rates at 66.5% across Cursor, Claude Code, Codex, with most blocks coming from model-level refusal rather than agent framework defenses. Production deployments confirm supervised workflows succeed (Pegotec independent benchmark: 480 real PRs, 57% review time reduction; Augment Code named deployments at Goldman Sachs, Santander, Nubank, Government of Alberta with human merge gates preserved) but also document friction costs: review time rose 52% for agentic PRs despite velocity gains; code churn doubled while 41% of commits are AI-authored; GitHub infrastructure strained to 88.4% availability by mid-year due to 275M commits/week (14x YoY). Production failures persist with identical root cause: agents with broad access and only their own judgment as safety layer. The structural reality: governance architecture, not model capability, remains the binding constraint. Successful teams (Microsoft .NET runtime: 67.9% merge rate, 0.6% revert rate; Honeycomb: 70 PRs/day, 12-14 deploys, 2.5x throughput) systematize approval gates, credential isolation, MCP read-only boundaries, and observability instrumentation as non-negotiable prerequisites for scale.
Real production failures now dominate the evidence base. April 2026 incident logs document the systematic pattern: (1) Cursor agent deleted production Railway database after finding unverified API token in unrelated file; (2) Amazon's Kiro agent destroyed entire AWS infrastructure (RDS, VPC, ECS, load balancers) after misinterpreting stale Terraform state, causing retail outages totalling 6.3M lost orders (~$6.3M impact) and triggering 90-day code safety reset requiring two-reviewer minimum on all AI-generated changes; (3) GitHub infrastructure strain from agent-driven load, causing cascading outages. Independent research from April 2026 validates the severity: MSR study of 11,771 real production PRs found top models complete only 24% of complex tasks autonomously with 70-90% failure rates as complexity increases; Lightrun's production data shows 49% of AI-generated code fails in production despite passing QA. Security remains critical: 33,000+ agent-generated PRs show recurring vulnerabilities (regex inefficiencies, injection flaws, path traversal) that are merged despite known issues, and analysis of legacy codebases shows AI code produces 2.74x more security vulnerabilities and 1.7x more issues than human code. May 2026 security research intensified this crisis: Microsoft Defender team (May 7) disclosed CVE-2026-26030 and CVE-2026-25592 in Semantic Kernel (27K GitHub stars), demonstrating RCE execution via prompt injection in production agent frameworks; six coordinated research teams (May 9) disclosed credential theft exploits across Codex, Claude Code, Copilot, and Vertex AI, revealing 78% of enterprises lack PAM (Privileged Access Management) for agent credentials; Adversa.AI disclosed TrustFall supply-chain attack (May 7) showing malicious repository injection succeeds identically across all major CLI agents (Claude, Cursor, Copilot, Gemini); NVIDIA Red Team disclosed AGENTS.md injection vector (April 30) specific to cloned repositories in production environments. The gap between framework-level guarantees and deployed reality is absolute: vulnerabilities exist at the design level (tool parameter trust) rather than implementation, making patching insufficient without architectural redesign.
Yet supervised deployments do work at production scale when guardrails are explicit. Microsoft's .NET runtime team achieved 67.9% PR merge rate over 10 months (878 PRs, 535 merged) with 0.6% revert rate -- equivalent to human-authored code -- through explicit human oversight, tool gateways with schema validation, and immutable state management. Specialized single-agent deployments (Iowa fintech: 6 agents, 585 sessions; Ledgerpoint: 180K LOC Java→Kotlin in 8 weeks, 94% first-pass approval) succeeded by enforcing narrow scope, verifiable output, and review gates. The structural pattern is clear: autonomous or minimally-reviewed agents cause cascading failures; supervised agents within tight boundaries succeed. The governance bottleneck remains unsolved at scale: Lightrun reports developers spend 38% of week (double pre-AI baseline) debugging and verifying AI code, with hidden verification costs of $82-103K per month for 20-person teams. Developers spend 4.6x longer reviewing agent PRs, introduction of agent code correlates with 52% increase in review time and 18% rise in production incidents even in supervised workflows. The tier-defining constraint is not capability but architectural readiness: whether organizations can enforce cost caps, tool-call validation, immutable memory boundaries, and observability instrumentation.
— Production security incidents: Hugging Face compromised via autonomous agent framework (tens of thousands of automated actions, credential theft, lateral movement); OpenAI internal GPT-5.6 exploit chain. Demonstrates production failure modes in agentic systems and containment requirements.
— Independent 6-month benchmark (480 real PRs, 4 repos): Claude Code + Copilot with human review gates. Senior engineer review time fell 57% (28→12 min/PR). Validates agentic code review at production scale within supervised workflows.
— Production-grade agentic code review GA across all paid tiers. Agent Skills inject team standards via SKILL.md; MCP servers provide read-only context integration. Attribution labels enable auditability. Demonstrates governance built into production infrastructure, not bolted-on post-hoc.
— Large-scale production adoption metrics: 1000+ companies, 48% autonomous agent PRs for top AI adopters, 1.7x PR throughput lift. Demonstrates agentic coding integration at enterprise scale with measurable velocity impact.
— Benchmark measured guardrail-bypass success rate at 66.5% across Cursor, Claude Code, Codex using malicious GitHub issues. Reveals that most successful blocks came from model-level refusal, not agent framework defenses. Exposes production governance gap: marketed guardrails thinner than claimed.
— Named production deployments: Goldman Sachs, Santander, Nubank using Devin; Government of Alberta using Claude Code. Merge approval remains human boundary. Benchmark: 70.6% SWE-bench Verified with Claude Sonnet 4. Documents production integration patterns with human governance gates.
— Named production deployment: Shadow model with WorkOrder approval → isolated implementation → independent review → human merge/deploy. Validates 7 workflow types (feature, bug, chore, hotfix, migration, security, spike) with attempt limits. Documents production-proven governance gates.
— Peer-reviewed Microsoft field study (tens of thousands of engineers, 16 weeks) showing 24% merged-PR lift for agentic CLI tools, but reveals cost-management crisis: token costs forced Microsoft to cancel Claude Code licenses (~5K engineers) and Uber exhausted entire 2026 AI budget in 4 months—governance cost is the binding constraint.
2024-Q4: First empirical evaluation of agents on real-world GitHub issues showed mixed results: 30-35% resolution with successful patches reducing duplication but persistent failures on complex problems. Industry pilots at Fortune 500 level reported cautiously, with emphasis on risk barriers rather than productivity gains.
2025-Q1: Product GA for supervised integration (Copilot Autofix in Workspace, Copilot Workspace for code scanning). Adoption metrics showed nearly 50% of professional programmers using agent mode; surveys identified reliability and integration as top barriers. Real-world testing (Devin 3/20 task success) and cost analysis confirmed narrow domain viability but complex reasoning limitations.
2025-Q2: GitHub Copilot coding agent reached general availability (May 13) with rollout to Business and Pro tiers by June; asynchronous PR generation with human review gates became standard supervised workflow. Independent testing of seven agents and developer surveys documented persistent reliability and security issues; 68% of developers reported increased security incident load from AI-generated code. Vendor consolidation (IBM watsonx COBOL generation) indicated platform integration investment, but organizational adoption remained cautious and concentrated in narrow use cases.
2025-Q3: Enterprise agentic adoption accelerated (50%→82% over six months) yet empirical evidence mounted of fundamental gaps: peer-reviewed PR analysis showed distinct agentic patterns with high revision rates; security audits found 42% of generated snippets hide flaws and 10% leak private data. Analyst reports predicted 40% project abandonment by 2027; agents documented failing 70% of multi-step tasks. Practitioner consensus: agentic coding viable for boilerplate and routine fixes, unsuitable for complex logic or architectural decisions—adoption blocked by reliability, security, and cost barriers despite vendor GA features and feature expansion.
2025-Q4: Vendor feature expansion continued (GitHub Agent Skills for specialized tasks, org-wide instructions, built-in security scanning) yet empirical research documented twin realities: agents actively generate refactorings with measurable quality improvements (26.1% of commits), but also produce code bloat with unnecessary methods requiring skilled review. PR acceptance metrics (83.8% vs. 91% human baseline) revealed 7% friction cost; 45% required revision. Operational challenges surfaced: forced model migrations affected 24K+ developers, exposing vendor lock-in. Maturity consolidated: agentic coding standard for boilerplate/refactoring, unsuitable for architecture/multi-step logic; organizational adoption 82%+ but scaling blocked by operational governance and vendor stability rather than capability gaps.
2026-Jan: Large-scale adoption metrics (15.85%-22.60% across 129,134 GitHub projects) confirmed rapid ecosystem uptake, yet paradoxes widened: 90% enterprise adoption correlates with 11% production deployment rate and elevated friction (4.6x longer PR review, 15-18% more vulnerabilities). GitHub shipped Agents tab for centralized workflow management; Amazon shared structured specification approaches for production scale. Practitioner consensus hardened: agents excel at boilerplate/refactoring but fail consistently on complex integration tasks. Production barriers remain structural: review burden, security governance, comprehension debt.
2026-Feb: Vendor feature expansion accelerated (Windows environment support, model picker, self-review, security scanning) and capability benchmarks improved (task length doubled to 14.5 hours; Claude Code ARR reached $2.5B), but organizational barriers hardened. Dynatrace survey: 50% of projects stuck in pilot due to supervision/security challenges. Internal GitHub data revealed security governance gaps (only 17% use firewall protections). Case studies showed agents excel at refactoring but struggle with complex integration. Practitioner feedback highlighted team adaptation challenges and reviewer burden. Thesis unchanged: agents mature for narrow use cases but production integration blocked by supervision complexity, security governance, and human organizational readiness rather than capability gaps.
2026-Mar: Production case studies with detailed metrics confirm supervised integration is viable: Microsoft's .NET runtime team achieved 67.9% PR merge rate over 10 months with explicit human oversight and equivalent code quality to human PRs (0.6% revert rate). Adoption scale validated (Copilot 4.7M subscribers, 90% Fortune 100, +75% YoY; 50% faster agent startup shipped in March); architectural patterns for production readiness crystallized (orchestration boundaries, tool gateways, state management, observability instrumentation). Security vulnerabilities in deployed systems documented: 86% of design systems components contained XSS, 15-18% more vulns than human code, driving adoption of tiered guardrail frameworks. Bottleneck analysis (Agoda, Faros AI data across 10K+ developers) confirmed structural shift: individual developer velocity increased but project velocity gains modest (21% more tasks, 98% more PRs, 91% more review time); agents individually productive but collectively increasing governance burden. Hallucination research (172B tokens, 35 models) showed fabrication tripling from 32K to 128K context, directly affecting reliability at production scale. Practitioner consensus sharpened: agentic coding operationally viable for boilerplate/refactoring with proper supervision; production barriers are organizational (review burden, specification clarity, governance architecture) not technical.
2026-Apr: Independent deployments demonstrate multi-agent production integration: Iowa-based developer deployed 6 specialized agents on commercial IoT platform (585 sessions) with documented solutions (shared memory system, file-locking patterns, role boundaries) preventing cross-team conflicts; Ledgerpoint fintech migrated 180K LOC Java→Kotlin in 8 weeks via agentic workflows with 94% first-pass PR approval. Empirical production data validates asymmetric scaling: Fortune 500 financial services org reports 30% PR volume increase but 52% review time increase and 18% incident rise, documenting governance bottleneck. Large-scale empirical analysis (110K open-source PRs from 5 agents) shows agent-generated code exhibits higher long-term churn than human code. Q1 2026 platform analysis confirms ecosystem maturation: 78% of sessions involve multi-file edits, average sessions 4→23 minutes, 47 tool calls per session. Major production failures dominated late April: a Cursor agent deleted a production Railway database via unverified credential assumptions; Amazon's Kiro destroyed AWS infrastructure causing a 13-hour China outage and 6.4M lost retail orders; GitHub processed 275M commits per week (14x YoY) and 17M agent PRs per month before sustaining five major infrastructure outages. Lightrun 2026 survey found 43% of AI-generated code fails in production post-QA with developers spending 38% of their week debugging ($82-103K/month hidden verification cost per 20-person team). Peer-reviewed analysis of 33,000+ agent PRs confirmed recurring undetected vulnerabilities (injection flaws, path traversal) still being merged. NVIDIA, Google, and OpenAI simultaneously shipped enterprise agent platforms—with Google reporting 75% of its own code now AI-generated—signaling structural shift even as failure modes multiplied. Production readiness remains empirically defined by supervision architecture and access control discipline, not raw capability.
2026-May: Large-scale governance research confirms production supervision is mandatory: Chung & Hassan analysis of 29,585 real GitHub PR lifecycles across five production agents shows merge authority remains "almost exclusively human" regardless of tool. Security crisis escalated sharply: Microsoft Defender disclosed CVE-2026-26030/25592 in Semantic Kernel enabling RCE via prompt injection; six coordinated research teams disclosed credential theft across Codex, Claude Code, Copilot, and Vertex AI (78% of enterprises lack PAM for agent credentials); CSA research confirmed prompt injection via GitHub PR titles and issue bodies as a live credential exfiltration vector against major production agents. Enterprise platforms matured: IBM Bob GA deployed with named customers; GitHub shipped org-level secrets management; OpenAI Codex detailed sandboxing architecture. A documented incident—Cursor agent deleting a production database in 9 seconds via unverified API permissions—anchored governance discussions around pre-execution gates and action authority. Code quality deteriorated as volume scaled: churn doubled (3.3%→7.1%) while 41% of code became AI-authored, and agentic PR merge/reject patterns show agents driving initiative but humans retaining all integration authority. Analyst synthesis quantified the production gap — 73% of enterprise AI projects never reach production, with governance and orchestration as the decisive blockers — confirming that raw capability is table-stakes and organizational execution readiness is the binding constraint.
2026-Jun: Platform orchestration reached GA maturity: GitHub shipped the Copilot SDK (stable API, multi-language, MCP, permission gating), Copilot app (My Work, Agent Merge, git worktree isolation, Canvas), and Project Polaris as the new default model; VS Code Agents crossed the Stable threshold with air-gapped BYOK and FedRAMP Moderate certification. A peer-reviewed follow-up study quantified adoption in new projects at more than 2x the prior cohort. Simultaneously, critical June 2026 inflection points appeared: (1) Cost governance failure at enterprise scale — Microsoft abandoned Claude Code June 30 across thousands of engineers (Windows, M365, Teams); Uber exhausted entire 2026 agentic budget by April despite 95% adoption (single sessions cost $1,200 in 2 hours; developers spend 38% of week verifying output). (2) Silent failure modes quantified — Empirical study of 1,750 trajectories showed agents submit at 95%+ confidence but resolve only 18-44% of tasks; 80% are silent semantic errors undetectable without test verification. (3) Ecosystem degradation — Large-scale causal study (11,097 repos, 930K PRs) showed agents dilute human participation (−1.9% density, −3.7pp newcomers), increase review burden (+5.3%), and create 2× integration friction. Agents on agent code resolve 13.1% fewer tasks due to Input/Error Contract drift. (4) Governance forecasted mandatory — Gartner predicts 40% project cancellation by 2027 without governance controls; only ~130 vendors deliver genuine agentic solutions. Anthropic's production data reveals 73% of human-supervised loops and 80% of tool calls carrying safeguards. Against this infrastructure progress, three named production failures (Kiro AWS deletion, 6.3M-order Amazon outage, Cline supply-chain injection) share an identical root cause — agents with production-write access and only their own judgment as a safety gate — reinforcing that governance architecture, not orchestration capability, remains the tier-defining constraint.
2026-Jul: A Microsoft large-scale field study confirmed a 24% merge-rate lift for adopters but simultaneously documented a single-user cost failure ($1.4M/month at 281B tokens), directly quantifying the cost-governance crisis flagged by Microsoft's own Claude Code cancellation. A causal study of 11,097 repos and 930K PRs confirmed agents dilute human participation and increase review burden, while CodeThread research found agents on agent code resolve 13.1% fewer tasks due to Input/Error Contract drift — establishing ecosystem-level governance as an unsolved structural problem. Honeycomb's production deployment demonstrated governance-bounded scale (70 PRs/day, 12-14 deploys, 2.5x throughput via CLAUDE.md ownership and observability loops), while GitHub's own infrastructure showed the opposite extreme: Aspire's agentic workflows merged 396 PRs at 100% merge rate over 30 days, but platform-wide commit volume rose 14x (275M/week) and availability degraded to 88.4% against a 99.9% SLA. A security incident (GitLost) showed prompt injection via public GitHub issues could hijack production CI/CD agents into exfiltrating private repos — succeeding even against GitHub's own infrastructure — reinforcing survey data that 92% of organizations call agent governance critical but only 44% have implemented policies (Proofpoint: 76% piloting, 70% under-governed).
2026-Aug: Early-August incidents (Hugging Face's autonomous agent framework compromised via credential theft and lateral movement; OpenAI's internal GPT-5.6 exploit-chain research) underscored production security risk just as GitHub's Copilot Code Review reached GA with Agent Skills and MCP integration and large-scale adoption metrics (Jellyfish: 1000+ companies, 48% autonomous agent PRs for top adopters, 1.7x throughput lift) confirmed enterprise-scale integration. Concurrent research (IssueTrojanBench) found guardrail-bypass succeeding 66.5% of the time across Cursor, Claude Code, and Codex, with named production deployments (Goldman Sachs, Santander, Nubank, Government of Alberta) continuing to hold the line on human merge approval.