2026 Agents Case Study Series Logo
How do you develop a runtime without developing the application built on top of it?
In the previous article, I explained how months of audits, implementation work, and conversations with AI eventually led me to recognize that A.I.N.D.Y. was developing into something closer to a runtime than the application I’d originally thought I was building.
And once I understood that, I decided to lean into it.
But deciding to build a runtime and understanding how to build one were two different things.
I still had a lot to learn.
So I approached the problem the same way I’d been approaching most of my development work.
I used AI to learn more about the concept.
I audited how that concept might fit into the system I’d already built.
Then I began working through the implementation using the same three phases I’d been applying to A.I.N.D.Y.’s other subsystems.
Phase 1 — Make It Real.
Phase 2 — Make It Intelligent.
Phase 3 — Make It Useful.
And just to clarify, when I say make it intelligent, I don’t necessarily mean adding an AI model.
I mean making sure the information, data, and outputs are being handled properly by the system.
The problem was that as I continued auditing A.I.N.D.Y., two findings kept coming back.
The repository was disorganized.
And business logic was being mixed with domain logic.
The first one I could understand, even if I wasn’t particularly happy about it.
The second one confused me.
Why Is the Agent Calling This Business Logic?
In my mind, A.I.N.D.Y. was one system.
I had the Infinity Algorithm, the formulas that supported it, the Memory Bridge, the execution mechanisms, and the various other subsystems I’d been developing.
And many of those capabilities were intended to be used throughout A.I.N.D.Y.
So when the audits kept identifying business logic mixed with domain logic, I wasn’t entirely convinced the agents understood what I’d built.
Because from my perspective, these weren’t necessarily isolated features.
They were parts of the larger system.
The formulas could be used by different components.
The Infinity Algorithm was supposed to help coordinate and evaluate different kinds of work.
The Memory Bridge was supposed to preserve continuity across execution.
So why were some of these things being classified as business logic?
Was the agent misunderstanding my architecture?
Or was I misunderstanding the distinction?
I decided to take the question back to ChatGPT.
The Difference Between a Capability and an Application
ChatGPT explained the distinction using an analogy involving Linux and applications running on a computer.
And that helped.
The way I came to understand it, at least for what I was trying to build, was that the runtime should provide general capabilities that multiple applications or services could use.
The application would use those capabilities to perform its own specific functions.
For example, an operating system can provide mechanisms for managing processes, accessing files, or communicating between programs.
But the operating system doesn’t need to know the specific business rules of every application running on top of it.
Those applications use the underlying capabilities to accomplish their own objectives.
And that’s where I began understanding what the audits were trying to tell me.
Just because something could be used throughout A.I.N.D.Y. didn’t automatically mean it belonged in the runtime.
The Infinity Algorithm and its formulas were a good example.
They were central to the application I’d been developing.
But they weren’t necessarily general-purpose execution infrastructure.
Another application might need scheduling, persistent workflows, memory services, or an event system.
That didn’t mean it needed my specific formulas for measuring productivity, focus, or progress.
The Memory Bridge required a slightly different distinction.
Its underlying persistence, recall, and orchestration mechanisms could provide reusable capabilities.
But particular rules about how A.I.N.D.Y. used those memories might still belong to the application.
The important question wasn’t simply whether something was shared.
It was whether the responsibility could be generalized beyond the particular application I’d built.
To be clear, I’m not presenting that as a universal definition of business and domain logic.
It’s the practical distinction that helped me understand my own architecture.
And once I understood it, the audit findings began making a lot more sense.
Organizing the Repository
The other recurring finding was repository organization.
And this one was slightly irritating.
Because I’d already spent quite a bit of time learning how to organize a repository.
I’d mapped files, created documentation, worked through implementation plans, and made changes intended to improve the structure.
Yet the audits kept telling me the repository was still disorganized.
But as I looked more closely at the findings, I began understanding why the agents considered it such a significant issue.
It wasn’t simply that the folders looked messy.
The repository wasn’t communicating the boundaries between responsibilities clearly enough.
An agent could inspect a file and understand what that file did.
But that didn’t necessarily tell it where a new implementation belonged.
Or which other components depended on it.
Or whether a particular service was supposed to be part of the runtime or the application.
And as the system grew, those distinctions became increasingly important.
So I decided to audit the repository specifically for organization.
We mapped the existing structure.
Identified the responsibilities of different components.
Examined their dependencies.
And developed a plan for restructuring the codebase.
Then I used Codex to carry out the organization work.
This wasn’t simply moving files into folders with better names.
It was about establishing clearer boundaries and making the repository easier for both me and the agents to understand.
The structure itself needed to communicate something about the architecture.
What belonged where.
Which components owned which responsibilities.
And how the different parts of the system were supposed to interact.
Once that work was completed, the repository became easier to work in.
The agents had clearer boundaries.
The documentation provided more useful context.
And I had a better understanding of how the system was organized.
But then another problem became apparent.
Organizing the Repository Wasn’t Enough
Even with a better-organized repository, I was still developing the runtime and application together.
And that created a different kind of problem.
A change could be correct within the component being modified and still affect another part of the system unexpectedly.
Not necessarily because the agent had misunderstood the instruction.
Not necessarily because the code it generated was incorrect.
But because the system had multiple dependencies and touchpoints.
Changing one implementation could affect another service.
Updating a shared model could change assumptions elsewhere.
And modifying execution infrastructure could affect application workflows that depended on it.
That’s part of working with an interconnected system.
But it was becoming a problem for the way I wanted to develop A.I.N.D.Y.
Because I’d committed to building the runtime as something that could support more than just my application.
Yet I was still developing it inside the same environment as the application itself.
So I found myself asking another question.
How do I develop the runtime without developing the app?
And that question led me back to ChatGPT.
How Do I Develop the Runtime Without Developing the App?
By this point, I’d already learned that the runtime and application had different responsibilities.
I’d reorganized the repository to make those responsibilities clearer.
But they were still living together.
And the more I thought about it, the more I realized that clearer folders weren’t necessarily going to solve the underlying problem.
I needed a way to work on the execution infrastructure without constantly bringing application-specific behavior along with it.
And I needed the application to keep using those capabilities without depending on their internal implementations.
That was the beginning of the decomposition.
Not because I wanted multiple repositories.
Not because I thought splitting everything apart automatically made the architecture better.
But because I needed to establish boundaries that could survive independent development.
The question was no longer simply where a file belonged.
It was what a component needed to own, what it was allowed to depend on, and what the rest of the system should be able to expect from it.
And that led to a larger separation of responsibilities.
Four Responsibilities, Four Owners
The decomposition work began with another repository audit.
Claude Code examined the existing code, imports, packaging, tests, migrations, and application surfaces to determine which responsibilities could operate independently.
The resulting architecture separated A.I.N.D.Y. into four primary areas.
The Runtime
The underlying execution infrastructure.
This included the kernel, persistent workflows, scheduling, memory infrastructure, event handling, worker behavior, and the mechanisms responsible for governing execution.
Its job was to provide capabilities that other applications and services could use.
The SDK
The interface through which other software could interact with the runtime.
Instead of requiring consumers to reach directly into runtime internals, the SDK provided an intentional way to access its capabilities.
The UI Kit
The reusable interface components and contexts that could be shared across different frontend applications.
These weren’t supposed to contain the specific business behavior of A.I.N.D.Y.’s application.
They were supposed to provide reusable interface building blocks.
The Application
The product-specific behavior I’d originally been developing.
The Infinity Algorithm, its formulas, Genesis, and the other application-facing workflows could use the runtime without needing to become part of the runtime itself.
That was the distinction I’d been trying to understand when the earlier audits identified business logic mixed with domain logic.
And now we were turning that conceptual distinction into an actual architectural separation.
But defining four areas was only the beginning.
The difficult part was making sure those boundaries were real.
A Boundary Isn’t Real Just Because You Moved the Files
This is where the technical work became important.
Because separating a system isn’t simply a matter of creating four repositories and moving the appropriate folders into them.
If the runtime still imports application-specific services, then the runtime isn’t truly independent.
If the SDK needs access to private runtime modules, then the public interface isn’t doing its job.
And if the UI kit depends on application-specific screens or APIs, then it isn’t as reusable as its name suggests.
So the agents had to inspect the actual dependencies.
Not just the filenames.
Not just the folder structure.
The imports, tests, models, migrations, and execution paths.
And sometimes those findings changed what we originally thought should be moved.
For example, the SDK was already largely self-contained.
It had its own package metadata, tests, and examples.
The audit showed that it could become an independent package without needing to carry runtime internals along with it.
That extraction eventually produced a standalone SDK with its own CI and 47 passing tests.
The UI kit required more careful examination.
Some components looked reusable until their dependencies were inspected.
The audit identified 21 files that could be extracted and six candidates that needed to remain outside the shared package.
The resulting UI kit could be consumed by multiple frontend surfaces without duplicating the same implementations everywhere.
And the runtime itself needed to become independently installable, testable, and operable.
That required more than separating Python modules.
It needed its own packaging, CI, runtime-owned database migrations, operational interfaces, and tests.
The application also needed to stop owning infrastructure that now belonged to the runtime.
The technical work was extensive.
But the objective remained the same.
Make the boundaries enforceable rather than merely descriptive.
Keeping the System Working While Pulling It Apart
One thing I had to account for was that A.I.N.D.Y. already worked in many areas.
I wasn’t starting from scratch.
And I didn’t want to break existing functionality simply to make the architecture look cleaner.
So the decomposition used compatibility mechanisms where they were necessary.
For example, some frontend imports continued working through thin re-export files while the actual shared implementations moved into the UI kit.
Earlier execution paths had used similar redirecting mechanisms when the persistent flow engine replaced legacy implementations.
That allowed ownership to move without requiring every dependent component to change at once.
But there was an important distinction.
A compatibility layer was acceptable when it preserved one source of truth and allowed the system to transition toward the intended architecture.
It wasn’t acceptable if it created duplicate implementations or allowed the supposedly independent runtime to depend on the application again.
The agents had to preserve those boundaries while maintaining the behavior that already existed.
And testing became especially important.
The runtime needed to pass its own tests.
The SDK needed to verify its public interface.
The UI kit needed to build independently.
And the application needed to continue functioning while consuming the newly separated components.
That was how we could begin establishing confidence that the separation had actually worked.
Not because the folder structure looked correct.
But because the individual components could operate under their own contracts.
The Tests Had to Move With the Responsibilities
Something else became apparent during the decomposition.
When you move a responsibility into a different repository, you also have to move the evidence that proves it works.
Tests that made sense inside the original application didn’t necessarily make sense inside the runtime.
Some test fixtures referenced application-specific database sessions.
Others assumed services existed in the same package.
And some integration tests depended on infrastructure that had previously been provided by the larger application.
Those assumptions had to be examined and corrected.
The runtime needed tests for the capabilities it now owned.
The SDK needed tests for its own public contracts.
The UI kit needed to prove it could be built and consumed independently.
And the application needed to verify that it still worked with the separated packages.
The same applied to database migrations.
If the runtime and application both believed they owned the same tables, moving the code wouldn’t resolve the architectural conflict.
So ownership had to be made explicit there, too.
This was another example of why the original question mattered.
How do you develop the runtime without developing the app?
You establish which responsibilities belong to each one.
Then you make sure the implementation, tests, packaging, and dependencies respect those responsibilities.
What Decomposition Actually Changed
By the end of the work, A.I.N.D.Y. had been separated into distinct artifacts.
The runtime could be developed as its own execution platform.
The SDK could provide access to its capabilities.
The UI kit could support multiple interfaces.
And the application could continue providing its product-specific functionality on top of those shared capabilities.
That didn’t mean the components stopped depending on one another.
They were still part of the same larger ecosystem.
But their relationships were becoming explicit.
The application could depend on the runtime’s public capabilities.
The SDK could communicate through defined interfaces.
The UI kit could provide shared components without importing application-specific behavior.
And each repository could establish its own tests, release process, and ownership boundaries.
That was a different kind of organization from what I’d done earlier.
The first restructuring made the repository easier to understand.
Decomposition made the responsibilities independently accountable.
And that’s the distinction I’d been missing when I first started questioning the audit findings.
The Architecture Had to Survive Being Pulled Apart
Looking back, this was another case where working with AI helped me understand an architectural problem before I fully understood the terminology being used to describe it.
The agents kept identifying business logic mixed with domain logic.
I questioned whether they understood my system.
ChatGPT helped me understand the distinction between general-purpose capabilities and application-specific behavior.
I used Codex to reorganize the repository around clearer responsibilities.
Then I discovered that better organization didn’t necessarily eliminate the coupling between the runtime and the application.
So I went back to ChatGPT with another question.
How do I develop the runtime without developing the app?
And that question led to the decomposition work.
Claude Code helped inspect the existing dependencies, identify which components could be separated, preserve compatibility where necessary, and verify that the new boundaries were being respected.
But the important part wasn’t simply that the agents could move code between repositories.
It was that I was learning why those boundaries mattered and how to establish them in a system I’d already spent months building.
Earlier in this series, I explained how I used God Files to compress architectural ideas into something I could inspect and reason about.
Now I was doing almost the opposite.
Taking a system that had grown together and separating it into components that could stand on their own.
But the objective was still the same.
I wanted to understand what I’d built.
I wanted the architecture to reflect what the system was supposed to do.
And I wanted a development process that gave me enough evidence to trust the changes being made.
The architecture survived because its contracts could survive being pulled apart.
What’s Next?
If you’re new to the series, you can catch up on the story so far:
- Article 1 — I Created a Coding Language — How a simple question to ChatGPT became a programming language experiment, and what happened when I let Codex work on it overnight.
- Article 2 — Chat Was Control — How I began directing Codex through persistent project documents, implementation constraints, and a manual agentic workflow.
- Article 3 — What a Version Promises — How architecture analyses, version control, and AI-assisted evaluation began changing the way I preserved and verified agent-generated work.
- Article 4 — I Built My Own n8n — How an automation question led me to build a runner with Gemini, question its place in my architecture, and begin integrating it into A.I.N.D.Y. with ChatGPT and Codex.
- Article 5 — It’s Just a Conversation — What working across different AI systems taught me about context, tools, execution environments, and why the model alone doesn’t determine what an AI can accomplish.
- Article 6–1 Week to Vibe Code V1 — How my attempt to finish Nodus in a week led me from Codex to Claude Code and helped turn conversational testing requirements into enforceable engineering practices.
- Article 7 — Discovering The Arcitecture — How Gemini, ChatGPT, and Codex helped me discover where the Nodus Runner belonged and begin defining the execution architecture A.I.N.D.Y. needed.
- Article 8 — Prototyping with AI — How I developed a repeatable AI-assisted prototyping method, used single-file implementations to preserve architectural ideas, and worked with coding agents to translate those ideas into existing software.
- Article 9 — Where Does the Work Exist? — How auditing A.I.N.D.Y.’s Memory Bridge with Claude Code changed my development workflow, helped me understand my own architecture, and taught me to evaluate agent-generated work through repository evidence rather than blind trust.
- Article 10 — Wasn’t I Building an App? — How auditing and integrating A.I.N.D.Y.’s existing subsystems led me to recognize the runtime emerging beneath the application and decide to develop it deliberately.
By this point, I’d learned that organizing a repository and establishing independent architectural boundaries were two different things.
A.I.N.D.Y. had been separated into a runtime, SDK, UI kit, and application, each with its own responsibilities, interfaces, and tests.
But separating the system didn’t eliminate the possibility of incorrect assumptions.
And as I continued working with coding agents, I began recognizing another problem.
The instructions I gave an agent could be wrong.
Not necessarily because I didn’t understand what I wanted to accomplish, but because the repository might have changed, an implementation might already exist, or an earlier audit might have misunderstood how something worked.
And the more detailed my instructions became, the easier it was for an agent to follow an incorrect assumption very precisely.
So the next development in my workflow wasn’t simply writing better prompts.
It was establishing a process where the agent could investigate the instructions themselves, identify when the code contradicted an assumption, and stop rather than implement a change the repository didn’t actually need.
In the next article, I’ll explore how this approach developed through A.I.N.D.Y.’s runtime audits, why I began treating disagreement as a useful part of agentic development, and how tests, contracts, and live verification helped determine when an agent’s findings were justified.
The next installment of the 2026 Agents Case Study Series is coming soon.
Explore the Projects
The systems discussed throughout this series are part of the Masterplan Infinite Weave ecosystem. While not every project has appeared in the story yet, you can explore the technology, examine the source code, and follow its ongoing development.
- Nodus — The programming language that began as the experiment documented in this series. Explore Nodus
- A.I.N.D.Y. Runtime — The governed execution substrate supporting workflow orchestration, persistent execution, memory, and agent coordination. Explore A.I.N.D.Y. Runtime
- A.I.N.D.Y. Platform — The application platform built on the runtime, bringing the underlying capabilities into usable applications and interfaces. Explore A.I.N.D.Y. Platform
- Masterplan Infinite Weave — The broader ecosystem connecting these projects and their ongoing development.
Previous Work
This series builds on the ideas, experiments, and lessons documented in my earlier work.
- 2025 ChatGPT Case Study Series — The original exploration of learning, building, and executing through sustained human-AI collaboration. Read the Series
- 2025 Duality of Progress Series — An exploration of the relationships between constraints, creativity, iteration, and progress. Read the Series
Originally published at https://www.linkedin.com.
Top comments (0)