Agentic development did not fix delivery. It exposed it

Enterprise delivery has always moved slower than development. A feature can be built quickly, but getting it into production still depends on access, security reviews, environments, permissions, data ownership, integration, UAT, operational readiness, and customer adoption.

For years, we could manage that gap through spreadsheets because build effort still represented a meaningful share of the delivery timeline. Agentic development changed that balance dramatically and exposed how wide the gap could become.

With agentic development, an integration that once took weeks can now be built in a day, while its path to production remains largely unchanged. The result is a widening gap between what a team can produce and what an enterprise can safely adopt.

This creates a new leadership problem: work can look complete while remaining blocked by the conditions required to operate it. Projects can appear active without moving materially closer to production, and engineers can finish the build while the delivery state remains unresolved.

We quickly found that traditional measures of progress had become less reliable. They were designed for a world in which development effort and delivery progress moved together closely enough for one to serve as a proxy for the other. We needed a way to make delivery readiness visible, evidenced, and reusable across projects so that each project could make the next one easier.

FieldOne is the system we built to do that.

FieldOne started as a spreadsheet that tracked live projects, effort, owners, dates, blockers, and slippage, which made the traditional delivery model visible and gave us a single place to plan the work.

The spreadsheet could show that an engineer was allocated to a project, but it could not capture the widening gap between compressed build time and the realities of enterprise deployment. Most importantly, a spreadsheet could not show the significant opportunity that the new way of working was presenting: engineers could now complete a build, switch context, support another project, or feed work back into product while an integration sat waiting on access, validation, or a customer environment.

Agentic development changed what we needed to see: the amount of code being produced no longer told us how much delivery progress had actually been made.

For a growing field engineering team operating across more concurrent projects, the spreadsheet could no longer represent the work. We needed a shared state that showed what was active, what was ready, what was blocked, and where agentic speed was creating leverage or risk. If the original spreadsheet tracked hours, the next system needed to track delivery truth.

The second iteration of FieldOne was still a spreadsheet, but it gave us a more useful view of delivery by plotting milestones over time and layering in the skills, owners, and dependencies required at each stage. What looked like a planning tool soon exposed the operating shape of the problem: projects were no longer moving in step with engineering effort, but through periods of build, waiting, validation, handoff, and escalation, often with responsibility shifting between field, product, the customer, and external system owners along the way.

That view made readiness easier to locate. We could see where a project had stopped needing active engineering but was still unable to advance, where the next dependency sat outside the person formally assigned to the work, and where delays were accumulating without appearing in the capacity plan. Access, environments, permissions, data ownership, validation, security, UAT, and operational readiness were shared delivery conditions, and when they were not surfaced early, they returned later as rework, delay, and commercial risk.

As the model became more useful, the spreadsheet became less able to contain it. The relationships between projects, milestones, owners, dependencies, evidence, and risk were becoming too complex for rows and formulas, while the reporting and workflow logic increasingly belonged in a system rather than a shared file. So we moved FieldOne into a dedicated application with its own database, backend, user experience, reporting layer, and workflow model, all built on our own product layer, ContextOne.

That transition turned FieldOne from a planning aid into the system of record for delivery state, with structured objects and lifecycles for projects, phases, ownership, evidence, risk, and readiness. ContextOne supplied the integration, automation, and agent capabilities around it. Delivery conditions became visible, repeatable, and governable without requiring agents or operators to reconstruct the truth from scattered updates.

Once delivery existed as a structured state rather than rows in a spreadsheet, we could begin designing the operating model around what the data was showing us. That model settled into four practices: classify work by delivery archetype, promote repeated work into certified capability, make delivery health evidence-based, and make the reliable path the default.

The first pattern FieldOne made clear was that projects differed less by size than by the shape of the work required to move them forward. No two projects were the same, but they rhymed. Most fell into three broad archetypes, each with a different mix of skills, dependencies, and operating risk.

Agent-heavy projects reused a significant amount of capability from ContextOne and required relatively light last-mile configuration or integration. Their progress depended less on new infrastructure and more on subject-matter expertise, workflow validation, and clear acceptance criteria. The technical work often involved configuring an agent loop around a known set of tools, behaviors, and validation steps, while the harder part was confirming that the workflow reflected how the customer actually operated.

Integration-heavy projects connected fragmented data and processes across multiple systems. They required more field customization and more coordination across system owners, permission models, data structures, and reconciliation logic. They also generated some of the most valuable product learning, because connectors and workflows that began as project-specific work often revealed patterns that could be hardened and reused elsewhere.

Build-heavy projects extended the boundaries of the product itself. These were first-of-a-kind deployments that required new capability, such as a fully air-gapped on-premise environment, a custom operating system kernel, a 1,000-user concurrency certification, or a customer-led UAT process supported by dashboards that operational teams could use without us in the room. They needed deeper involvement from product, engineering, and infrastructure because the delivery work was also creating part of the future product.

The archetypes helped us understand why projects with similar timelines could require completely different interventions. Agent-heavy work needed more subject-matter expert (SME) access and UAT coordination. Integration-heavy work needed stronger project management and cross-system ownership. Build-heavy work needed deeper product and architectural support.

Once those differences were explicit, we could design delivery pods around the actual shape of the work rather than staffing every project as though it followed the same path. The same model improved capacity planning, clarified where risk was likely to appear, and helped us distinguish between work that should remain customer-specific and work that warranted product investment.

The next question was what should happen when the same integration, workflow, connector, or agent behavior appeared across several projects.

A working implementation was not enough to make something reusable. Production constraints such as environment parity, permission models, scale, rate limits, payload size, timeouts, monitoring, rollback, and operational ownership could still be untested, even when the feature worked correctly in development. Reusing that work without understanding those limits simply moved the uncertainty into the next project.

We created a promotion path that turned repeated project work into certified capability. To move into the product path, the work needed a named owner, supporting evidence, defined prerequisites, known operating limits, reuse criteria, and production-readiness checks. This gave the next team something they could depend on rather than a previous implementation they first had to reverse-engineer.

The purpose was to make learning portable. A project should leave behind more than code that once worked in a particular environment. The next project should inherit progress, not repay the zero-to-one cost.

Defining what made a capability reusable also forced us to define its production conditions earlier. Many of those conditions were knowable before kickoff, which changed how we approached pre-sales. We introduced a small set of questions covering the systems involved, the applicable permission model, the available environments, known technical limits, customer ownership, and the evidence that would count as production-ready in that operating context.

These questions did not add a new approval layer. They made assumptions visible before they became embedded in the plan, giving both sides a clearer view of the conditions required for delivery to proceed.

As the portfolio grew, project health became increasingly difficult to interpret because terms such as “on track,” “nearly complete,” and “green” often described different realities depending on who was speaking. One person might be referring to the state of the build, another to customer validation, and another simply to the absence of a newly reported blocker. Reviews therefore spent too much time reconciling competing versions of the project before the team could decide what required action.

We wanted those conversations to begin from a common set of facts: the dates and scope that had been committed, the current delivery phase, the evidence available, the age and ownership of open blockers, and the risks being carried into the next checkpoint. These questions became the basis of the Theta Dashboard, named after the options concept of time decay. In FieldOne, theta represented the delivery cost that accumulated as the committed plan and the current reality moved further apart.

FieldOne calculated carry, slippage, and trajectory for each phase by comparing planned dates and scope with the current forecast, evidence freshness, blocker age, active exceptions, ownership, and phase-gate status. The underlying fields remained deliberately simple, but together they made the delta visible early enough to act on. A project described as on track now needed an aligned forecast, current evidence, clear ownership, and an acceptable blocker and exception state, turning health from a summary judgment into a claim that could be inspected.

To support that model, we defined phase gates and checklists around the production conditions that mattered in practice. A gate was complete only when the required evidence existed or an explicit exception had been recorded. “Access verified,” for example, required an approval artifact or a successful test query linked to the milestone and a named owner, while “Environment parity verified” required evidence that the deployed configuration matched the production target. By tying sign-off to evidence, unresolved conditions became visible before they could pass silently into the next phase.

Evidence made risk visible, but it did not ensure that teams followed the reliable path once delivery came under pressure. Optional process disappears the moment urgency shows up, so the reliable path had to become the default path, built into the way delivery operated.

Deployment patterns, agent workflow templates, integration checklists, validation routines, rollback plans, and production-readiness criteria became first-class delivery assets rather than supporting documents scattered across folders and chat threads. Each pattern followed a consistent structure covering prerequisites, environment and permission checks, implementation steps, validation, rollback, and the criteria required for production use.

That structure turned individual experience into something another engineer could apply without first reconstructing the reasoning behind the previous deployment. A new field engineer could begin with a known pattern, confirm which prerequisites were already satisfied, and focus on the parts of the environment that were genuinely different. Customers and delivery teams benefited from the same clarity because both sides could see the established path, the decisions still outstanding, and the places where the deployment departed from the norm.

The model still allowed teams to move forward when reality required a deviation, but every bypass had to be recorded as an explicit exception with a rationale, owner, expiry date, available evidence, mitigation, and follow-up action. That preserved flexibility while turning silent risk into visible risk.

Over time, the exceptions themselves became a source of operational and product learning. When several projects bypassed the same gate for the same reason, the pattern pointed to a weak template, a missing readiness check, an unrealistic process, or a capability ContextOne needed to provide. Delivery friction could then be converted into a stronger default rather than rediscovered by the next team.

By this stage, FieldOne was no longer recording delivery after the fact. It was governing how work moved across field, product, agents, customers, and the systems they depended on.

The most important lesson from building FieldOne was that managing delivery in an agentic organization requires more than adding automation to an existing process. Once agents began compressing build time, shifting engineering capacity between projects, and turning delivery work into reusable product capability, we needed a system that could represent the new operating model directly.

That meant owning the delivery object model first. Projects, phases, owners, evidence, risks, decisions, dependencies, staffing, product signals, and health all needed to exist as structured state with clear relationships and lifecycles. Without that foundation, automation would have accelerated the production of updates without improving our understanding of what was actually ready, blocked, or at risk.

The separation between delivery state and the automation around it made FieldOne both useful and governable. FieldOne remained responsible for the record of what had happened, what had been approved, what was waiting, and what needed to happen next, while ContextOne provided the agents, integrations, and workflows that could act on that state. Agents could prepare meeting briefs, surface aging risk, draft customer updates, or recommend next actions, but they were operating within an explicit delivery model rather than reconstructing one from scattered context.

We also learned that signals beat status. A weekly review should not begin with each owner explaining whether a project feels on track, but with changes to the forecast, aging blockers, missing evidence, active exceptions, phase-gate status, and ownership of the next action. This shifted reviews away from reconciling competing narratives and toward deciding where intervention was required.

The same principle applied to process. Optional practices tend to disappear under pressure, so gates, templates, readiness checks, and evidence requirements had to become part of the default path. Teams could still bypass a gate when delivery required it, but the exception had to be named, owned, justified, time-bounded, and tied to mitigation. Flexibility remained possible without allowing risk to become invisible.

Over time, those exceptions, escalations, and postmortems created a compounding loop. A repeated problem could become a stronger gate, a clearer readiness check, a certified capability, or a reusable delivery pattern. Each project could therefore improve not only its own outcome, but the system used to deliver the next one.

That is the larger role FieldOne came to play: managing delivery in a world where agents had changed the speed, allocation, and economics of the work.

As AI reduces the effort required to build, the scarce resource becomes trustworthy progress: work that survives contact with a real customer environment, can be inspected and governed, and leaves behind reusable capability rather than another isolated implementation.

The goal is not to make enterprise delivery simple. It is to ensure every project makes the next one easier.