Software engineering as a discipline is arguably changing faster than any other field with the adoption of Agentic AI. We’ve gone from coding assistants providing fancy autocomplete to end to end agentic workflows fundamentally changing the SDLC. At Flatiron, we care a lot about quality. We have spent years extracting clinical variables from unstructured records at scale using AI. To do this while ensuring measurable quality means comparing model outputs against trusted reference data, involving clinical experts on ambiguous cases, and continuously measuring quality as models evolve. That work produced our VALID framework, because in healthcare "accurate" isn't enough. You need evidence that's measurable, repeatable, and defensible. With the VALID framework, accuracy is benchmarked and quality validated with every model change and developing the framework has been critical to injecting AI into our data strategy. The learnings around focusing on quality and evaluation have carried into how we integrate AI into how our developers work.
Building off the success of our data strategy, our engineers have worked to integrate the same principals and tools into how we work. We believe that software development tasks involve human expertise and judgement and AI has not changed that. What has changed is where that expertise lives and how it manifests. To establish common language on how we build trust in the system, our engineering team has defined an AI Maturity Model. This aligns strategic investment with capability demonstrated through assessment and evidence gathered from experiments.
A four-layer maturity model
|
Maturity Layer |
Human Role |
Agent Role |
|---|---|---|
|
Layer 1: Manual |
Authors code and retains full operational control over all changes. |
Acts strictly as an automated reviewer evaluating human-written code against rules. |
|
Layer 2: Interactive |
Prompts, steers interactively, and verifies suggestions step-by-step. |
Acts as a conversational assistant responding directly to engineer directives. |
|
Layer 3: Structured |
Orchestrates the overall process and reviews intermediate artifacts at phase gates. |
Follows explicit multi-phase workflows (specify, plan, implement) sequentially. |
|
Layer 4: Autonomous |
Monitors execution asynchronously and intervenes on edge cases or failures. |
Executes end-to-end multi-phase workflows independently within set guardrails. |
A team might run Layer 2 for routine changes and Layer 1 for a legacy codebase where agent-assisted review is the highest-value move available. What matters is that each layer's guarantees hold before the next one depends on them.
What actually moves as layers progress isn't how much human expertise is involved, but where that expertise lives. At Layer 1, it sits in the engineer's head, applied review by review. By Layer 4, it has to be externalized into the artifacts and checks that govern the agent's behavior, because there's no longer a human reapplying it each time. That externalization, not better models, is what unlocks trust at each step. It's fundamentally an evaluation problem to define what “good” looks like.
Evaluation has to become shared infrastructure
Evaluation naturally starts inside individual teams, but as autonomous systems scale, siloed QA quickly breaks down and decays as models evolve. Our approach centers on building foundational capabilities that define quality and remain extensible across diverse models and architectures. By treating prompts, steering artifacts, and agent configurations as core product components with full lifecycle management, we establish shared, repeatable infrastructure rather than fragmented point solutions.
Three extensible capabilities underpin this shared infrastructure to ensure long-term system reliability. First, universal observability embeds reasoning traces and tool calls directly into our standard CI pipeline across all models. Second, layered evaluation routes checks dynamically based on risk, combining deterministic validation, LLM judges, and expert human review. Third, closed-loop feedback automatically updates steering artifacts when fitness functions detect suboptimal outputs. Together, these capabilities form an extensible harness that scales quality across any underlying model and enables data collection for a self-learning system.
Reliability comes from the system, not the model
Swap the model under a well-built harness and it keeps working, because the guarantees live in the artifacts and checks, not the model's weights. Swap the harness out from under a good model and reliability disappears immediately. That asymmetry is the case for investing in the system alongside, not after, the next model upgrade.
The teams that succeed won't be the ones deploying the most agents or adopting models fastest. It will be the ones building evaluation into the platform itself. Concretely, that's meant a shared self-assessment against the four layers, so a team can say "we operate confidently at Layer 2, we're piloting Layer 3" rather than everyone claiming Layer 4 because that's where the attention goes. Models will keep improving. That's the easy part. The harder, more interesting problem is building systems that tell us when those improvements are real.
Where we’ve seen this working
At Flatiron, this approach is already proving its worth across all four maturity layers. Agent Code Review (Layer 1) offloads first-pass pull request reviews to automated agents guided by explicit domain and architecture rules, drastically cutting reviewer overhead in CI and accelerating time-to-merge for routine changes. Our internal Plugin Marketplace (Layer 2) empowers developers with domain-specific assistants that help them prompt, steer, and validate suggestions right inside their local coding loops. An Agent Evaluation Harness (Layer 3) treats quality as shared platform infrastructure, leveraging deterministic CI checks, LLM judges, and expert review to run multi-phase workflows against unified quality gates. Finally, our Agent Runtime (Layer 4) establishes a secure, scalable execution environment backed by robust orchestration, safety guardrails, and automated verification, allowing fully autonomous workflows to complete end-to-end tasks with minimal human intervention.
Solve Problems that Matter
The maturity model provides a common set of language to talk about investments and compare them cross team so we keep our organization moving in the same direction. We have always built our products by bringing together oncology and technology experts. By inserting agents into that team, our humans can spend more of their time focusing on applying their expertise to solving the problems that really matter. AI is a tool that helps us realize more use cases and the maturity model is a framework to ensure we are using AI in a responsible, quality first way that supercharges our mission to learn from the experience of every person with cancer.
