PlayerZero

Playbook for engineering leaders → playerzero.ai/resources/the-…

Most AI investment in eng goes toward writing code faster. But 40-45% of engineering time is still lost to triage, RCA, and validation after the code ships. The teams seeing real ROI aren't generating more code. They're closing the context gaps that slow everything else down. Link to the playbook below 👇

The reason AI coding works isn't what most people think. It's not about generating more code, faster. It's about changing the level of abstraction humans work at. McKinsey Technology CTO James Kaplan puts it precisely: AI-enabled software engineering lets you make declarative statements instead of procedural ones. You describe the outcome. The machine handles the implementation. That's a fundamental shift in how humans and machines divide the work, and it has implications well beyond coding. Any domain where humans currently spend their time on procedural execution rather than declarative thinking is about to change. Full episode: youtu.be/CgeyjTXXBhI

RAG optimization has a ceiling. Better prompts have a ceiling. Our CEO @akoratana sat down with @jaychia_ on Zero Shot Espresso to talk about why externalizing learning - through richer, more connected context - is the next frontier for enterprise AI agents. The labeling problem in production is real: there's no verifiable reward signal 100% of the time. Which means weight updates alone won't get you there. What actually moves the needle is how you represent context across decisions. Watch the clip to hear Animesh break it down. Full podcast: youtu.be/HztVHrcKGi4

We've spent decades optimizing the factory floor. The office building is still chaos. That's McKinsey Technology CTO James Kaplan's explanation for why context graphs went viral, and it's the sharpest framing we've heard of the problem we've been working on since day one. Knowledge work has resisted the productivity improvements we've applied everywhere else. Not because we haven't tried, but because it's decision-oriented, relies on ambiguous data, and lives inside individual heads rather than systems. Relational databases were built for transactions. They were never built for this. Get the full context: youtu.be/CgeyjTXXBhI

This is the year of AI adoption in the enterprise. More of @akoratana's hot (and lukewarm) takes in the full podcast with @jaychia_ : youtu.be/HztVHrcKGi4

Agents do not fail because they lack intelligence. They fail because they lack institutional memory. In the new episode of Zero Shot Espresso with @akoratana, we discussed context graphs and decision traces, and what it takes for AI systems to actually improve over time in enterprise environments.

Our CEO @akoratana joined the Zero Shot Espresso podcast with @jaychia_ to chat all things context graphs. Animesh covers why RAG plateaus, how agents should navigate governance and security, and what it takes to make AI systems improve over time in production. Full episode: open.spotify.com/episode/6uwlxP…

Agentic AI is moving from experimentation to production, and the standards that govern it matter. PlayerZero is proud to join the Agentic AI Foundation, alongside 145 other organizations working to advance open protocols and interoperability for agent-based systems. The foundation layer of agentic AI is being defined now. We're excited to help shape it. aaif.io/press/agentic-…

And just a few weeks later, Gartner says by 2028, 50% of AI agent systems will leverage context graphs!!

Everyone’s been talking about context graphs, but what do they actually look like in production? When a context graph builds up enough signal, it can turn into a production world model—a unified, living representation of software's actual production behavior. It's a continuously developing system that brings together code, configuration, infrastructure, runtime signals, tickets, and incidents into one cohesive world. The true test of whether your context graph has developed into a production world model is simple: can it predict the future? World models understand cause and effect well enough to predict outcomes. We call this Simulations. We've shipped Code Simulations (CodeSim) which runs what-if scenarios against your production system without executing a single line of code. Watch it predict how your system behaves when storage fails during an avatar upload. No test environment needed. No deployment required. Just pure simulation based on understanding the relationships between your code, infrastructure, and runtime behavior. The implications are wild: - Debug issues before they happen - Validate fixes without deployment risk - Understand blast radius of infrastructure changes - Train AI agents on realistic production scenarios Context graphs that can't simulate are just fancy documentation systems. But when they can predict how your system responds to specific conditions? That's when you've crossed into territory that changes how we think about production engineering entirely.

We've shipped something that changes how teams think about testing and QA: running production simulations directly in pull requests. Here’s how it works: PlayerZero spins up hundreds of test scenarios for a single PR - not by compiling and executing code, but by simulating how the code would behave under different conditions. It steps through the logic line by line, predicts pass/fail outcomes, and posts results directly back to GitHub. The unlock isn't just speed (though running a thousand scenarios without spinning up test environments is pretty fast). It's that we can now test against production reality instead of mocked approximations. When a simulation fails, you can ask PlayerZero to fix it. It traces through the code, makes edits, re-runs simulations on those changes, and verifies the fix - all before merging the PR. This is the shift from "test coverage" to "scenario coverage." Instead of asking "did we execute this code path?" we're asking "how does this code behave when the storage service is down? When there's a race condition? When session tokens expire mid-request?" Traditional CI/CD runs the code you wrote. CodeSim simulates the production conditions your code will actually face. The difference matters because production doesn't care about your test suite. It cares whether your system behaves correctly when reality gets messy. This is Production Engineering. Testing evolved beyond execution into true simulation.

The tl;dr on context graphs in this 🔥 video

The familiar operating model—people, process, technology—worked when systems were smaller. AI-assisted development changed that. Context, not technology, is now the limiting factor. Our new article explores why modern defect resolution requires a shift to people, process, context. Read it here: playerzero.ai/resources/peop…

Your 10x engineer is a bottleneck. Decisions concentrate. Progress stalls when they're unavailable. Teams built on distributed expertise move faster. Full system context means every engineer makes informed decisions without waiting for approval. Read the POV: playerzero.ai/resources/beyo…

The real gains for CTOs and VPEs come from reducing MTTR, preventing defects, and reclaiming engineering capacity. We built a playbook on how to measure and maximize AI ROI where it matters most: playerzero.ai/resources/the-…

Those token usage plaques OpenAI hands out? The real lesson is that token consumption correlates with how deeply AI is embedded in workflows, not company size. Tokens aren't spend. They're leverage. The organizations seeing returns measure tokens per employee: how much cognitive work each person can responsibly offload to AI. As teams scale this leverage, they're discovering traditional QA and observability weren't built for continuous machine reasoning. The winners are preparing for AI-native velocity before it forces their hand. playerzero.ai/resources/the-…

After @JayaGup10 and I published our context graphs p.o.v., the question we heard most was how do you actually build one? @akoratana wrote one of the most insightful answers I've seen. His core insight: you don't prescribe the schema upfront. You let agents discover it through use. When an agent investigates an incident or completes a task, it traverses your company's systems. That trajectory is a decision trace. Accumulate enough of them, and a map of how your organization actually operates emerges. "The schema isn't the starting point. It's the output.” This is also why startups have an edge. Agents can live in the execution path in a way traditional software can't - they’re present at decision time and can capture traces as a byproduct of work. Incumbents would have to retrofit this into workflows they don't control. It's been a month since we published the original piece. I wrote up what we've learned: what resonated, where we got pushback, and the questions we’re still working through: foundationcapital.com/context-graphs…

@nickfloats @akoratana wrote about this here: thenewstack.io/5-engineering-…

Big identity crisis in many engineering circles rn. People who've historically considered themselves "builders" now realizing they aren't the ones building shit anymore, AI is. The moral superiority of the "I build things, you just talk" mentality is irrelevant now that the coding language is english and anyone can build things by talking. The skills that made them so economically valuable are almost fully commoditized, and they're being forced to adopt a new identity. An identity most of them despise and have mocked their entire careers. To remain relevant, they must become the "idea guy"