Skip to content

How to fix already outdated product just after release in a week

Published on  · Updated on  · Igor Tkachenko

AI-generated illustration of Igor and three engineering owls in a busy workshop, including a comically short-circuited owl in the corner

After a year of work, my OwlMeans Platform is completely outdated. What am I going to do? This is the realization I had just after the release and tests with real users. They haven’t noticed — but I have. Of course I knew it at the end of the spring. Why didn’t I do anything about it then, and what’s going on? Let’s try to uncover it together.

I could have held the release and replaced the engine first. There was already a product to release, though, and the old implementation could remain available during the change. I want to rework its core in a week or so. The interesting question is how much of that core actually needs replacing.

OwlMeans still takes one user story through a predefined design and implementation process. Related features go through separate runs even when they depend on the same decisions. The proposed replacement keeps the dependencies and recovery machinery, but gives agents more freedom to investigate within each phase.

If you’d rather watch than read, start with this video. The Uroboros walkthrough covers the initial design: application boundaries, compatibility requirements and the transition toward hybrid execution.

My AI platform was outdated at launch. Here is what I am changing | Uroboros.

Stories and execution

A user story describes something a person needs. It does not necessarily describe a sensible amount of work for one agent run.

Take an order’s status. The customer sees it; the operator changes it. Two ordinary stories share states, access rules and API contracts. Send them through separate runs and the engine has to recover much of the same knowledge twice. Small cards do not make the application behind them smaller.

I used small stories to keep tasks within the context available for productive work. That also made progress visible. A failed run could resume without starting the whole project again. The compromise was reasonable, but it coupled the description of a feature to the execution strategy.

Later, I started experimenting with related tasks grouped around a subsystem. Shared behavior could be considered before producing the separate features that used it. I want to keep stories as descriptions and acceptance criteria while allowing related stories to share an execution.

Larger context windows give that experiment more room. They are hardly news: Google announced its limited million-token Gemini 1.5 preview in February 2024. But capacity alone does not select the relevant code or expose a dependency hidden in another package.

In Lost in the Middle, Liu and colleagues found that retrieval depended on where information appeared in the context. Their 2024 study covered particular models. For a current engine, the useful test is whether it finds and uses the code required for the change.

What belongs in a pipeline

Today, developing a story starts by creating a StoryDesign. It holds screens, components, interactions, data and runtime requirements. Implementation reads that saved design and writes the application. This gives the engine an artifact to inspect, amend and resume from.

Some design work runs in parallel. Other parts have to wait: layout decides where a component belongs before UX and data work use its path. Implementation has twenty named steps, including types, resources, domain logic, endpoints, workers, stores, views, access rules and navigation.

These dependencies have concrete consequences. A handler needs the declaration of the queued operation it starts. Access rules need an endpoint to protect, and navigation needs screens to point to. Code can enforce that order without asking a model to rediscover it on every run.

Each completed design step also persists a revision. If the process crashes, the next one can read the design and continue. A “done” marker with no saved work behind it would be a rather optimistic recovery mechanism.

I intend to keep this machinery. The pipeline fixes the execution order and dependencies. Its steps already call models for generated content and attempt repairs. It controls when those calls happen and what must exist before the next step starts.

The difficult decisions appear inside a step. Which files should the agent inspect? Has it found enough context? Does changing this component require a change to another one? The answers depend on what the agent discovers after it starts working.

Anthropic’s December 2024 Building effective agents separates predefined workflows from systems where a model chooses its next action. A hybrid can preserve the known dependencies while allowing investigation where the path varies. The engineering work is deciding which choices belong inside that boundary.

Agents inside and outside

The Free Flight console already puts an agent around the guided pipelines. It can inspect files and use coding tools. Where the host supplies the gateway, it can also design a story, read or amend that design, implement it and resume a run. Without the gateway, the lower-level tools remain available.

Calling a pipeline does not give the agent permission to change everything inside it. A design amendment can change what a component does. A path or alias allocated by the registry stays put, because other parts of the application already use that name.

Fatal conditions need the same distinction. An exhausted balance must stop the loop altogether. Return it as an ordinary tool error and the model can try another operation and spend again. That is a bad place to be helpful.

I want the arrangement in the other direction too: an agent loop inside a guided pipeline phase. The proposed phases are prepare, server side, website side, connect and verify. Within a phase, a work item carries its design, app, registry entries and contracts.

The agent reads relevant code, makes the change, runs a check and repairs what failed. When an attempt exposes a missing dependency, it can investigate before trying again. The outer pipeline no longer needs a new step for every discovery that can be handled locally.

That requires repeatable tools and checks that can run for one piece of work. After an interruption, replaying a write must not create a second artifact or lose an existing one. After a bounded run, the loop must return either a checked result or the details of what remains unresolved.

Today, an unanswered story endpoint can fail validation. A smoke test can leave a warning after bounded repair. Those outcomes mean different things. A local loop must preserve the distinction when returning control to the containing pipeline.

I will keep a simple workflow as a baseline. Xia and colleagues’ 2024 Agentless competed with the open-source agents evaluated on SWE-bench Lite using structured localization, repair and validation. An agent loop has to earn its place.

The 2024 SWE-agent paper showed how repository navigation, editing and test interfaces affected an interactive agent’s results. So “add a loop” is barely the start of the job. The tools around it and the completed behavior still need evaluation. Neither paper establishes the result for OwlMeans.

Shared work across applications

For the order example, a grouped run would plan status transitions with both customer and operator stories in view. Their screens and endpoints would use that shared decision. Splitting the implementation into smaller pieces would still be useful; repeating the domain design would not.

The engine already shares stage state within a story. A coordinated run needs working context and a registry across stories, with a separate outcome for each one. If one story remains partial or fails, the result must say which one and why.

Sending the whole repository with every call would be a poor use of shared context. Start with the design and known contracts; read implementation details when the work reaches them. Anthropic describes this use of references and tools in its September 2025 context-engineering guidance.

One run can still contain many calls, checks and checkpoints. Its purpose is to keep connected decisions together across those calls. I have yet to measure whether the results improve or the reduction in repeated context amounts to anything useful.

The generated project’s structure creates another boundary. Today it has one website and API serving guest, user, admin and operator areas. An area describes who a screen is for. It does not give a separate application its own frontend and API structure.

OwlMeans itself already has a more complicated arrangement. Its customer interface, management services, agent execution and publishing have different responsibilities. A generator that understands only one web/API pair cannot describe something comparable.

The Uroboros plan adds an app map to assign areas and functionality to apps. Data, business logic and workers stay shared underneath. When a story affects several apps, the engine has to follow the change through all of them.

Path resolution, design, implementation, previews, publishing, runtime status and connector tools all need changes. Adding “support multiple apps” to a prompt won’t do that work.

For an existing project without an app map, the proposed fallback is one main app. Its paths and behavior stay in place. Changing the engine’s vocabulary should not force customers to rebuild working projects.

The migration and Uroboros

I am giving the core change a week or so. That remains a target, not a completed result.

The first slice covers foundations and app routing. Agentic building within phases comes next in the wider plan, followed by coordinated runs for related stories. The migration needs the old pipeline available beside its replacement. Existing runs must finish where they started; the new path can be enabled project by project.

The first compatibility check is deliberately unexciting: bring an existing project into the development environment and make sure it still starts and works. Further end-to-end checks cover supervision, chatbot behavior and a small planned project using the new structure.

Compare the same reference products through both engines. Record failures, warnings, functional results, elapsed time and model usage. A successful build cannot tell whether the customer and operator see the same order state. That requires a check of the flow itself.

In its March 2026 long-running application harness experiments, Anthropic combined planning, generation and separate evaluation. The team also simplified parts of the harness as model behavior changed. An orchestration step should remain because it solves a current problem, rather than because it once did.

Uroboros is the attempt to make OwlMeans develop a system as complex as itself. Multi-app support supplies the structure; coordinated runs and agentic phases address the work across that structure. Together they create a path toward a supervised self-development trial.

I already use an external coding agent to change the engine. I want to give comparable work to OwlMeans’ own generation workflow, then check the result independently.

That trial needs an isolated environment, a defined change and a recoverable previous version. Editing the engine’s source is one outcome. Demonstrating that the edited engine works better requires its own evidence. I will keep responsibility for that judgment.

OwlMeans