CRUD holds the data.
Create, Read, Update, Delete. Dedicated workers handle storing and retrieving information.
A project in the making · An idea worth exploring
What if building a business system felt more like connecting the work you already understand?
Small workers. Shared documents. Readable pipelines.
A place for AI, with clear rules for what runs.
If you use app builders, you already think in records, rules, triggers and actions. An order arrives. Someone checks it. A price is calculated. The result goes somewhere.
Yet each application often rebuilds the same connections, hides rules inside screens, and makes a small change feel bigger than it should.
CRUD and Logic asks: can we make those pieces explicit, reusable and easy to rearrange?
Create, Read, Update, Delete. Dedicated workers handle storing and retrieving information.
Check a quantity. Apply a pricing rule. Work out a delivery date. Each worker has a focused job.
The sequence is a separate description. Change the route without hiding new rules inside a screen.
Think of a flow in an app builder, carried down into the architecture of the whole system.
Instead of one large program doing everything, a document moves through workers. Each reads what it needs, does its job, and passes the document forward.
A person or a connected system supplies the order. This example begins with an order page and its line items.
The same context travels with the work.
Select any step to explore it. This animation explains the proposed runtime; it does not submit an order.
Between jobs: a hand-off. Queues give each stage somewhere to receive and pass on documents. Capacity, retries and failure handling still need explicit rules.
Outside the happy path: a failed check should produce an error page or a defined error route. The system must make failure visible, not silently continue.

One envelope. Many kinds of information.
A Document holds the context for a business process. Inside it, Pages carry different kinds of information.
A worker reads the pages it understands, leaves unfamiliar pages alone, and adds the result of its work. The next worker gets the context as well as the result.
That shared contract is what makes replacement possible: a different implementation can do the same job if it honours the same inputs and outputs.
What is actually inside a Page? ↘A pipeline should make business sense to the people who use it: their domain, their terminology and their cultural context. The same workflow may be described differently across organisations, languages and regions. An interpreter turns that defined business description into a pipeline of worker programs. The boxes below represent processes doing the work, not just steps in a sequence diagram. Each receives a Document, performs its job and passes the Document onward.
“Receive the order.
Check its details.
Calculate the total.
Save and return the result.”
Cultural sensitivity is part of the design: names, dates, currencies, local conventions and the meaning of a business step must be explicit. Translation alone is not enough. The business language describes intent; the implementation language does the work. Domain interpreters are planned work. The .exe names illustrate executable workers on Windows; other platforms and devices can implement the same document contracts.
The intent is assembly code: small, specialised modules operating close to bare metal. Some jobs could even run on bespoke PCIe devices. The architecture itself is agnostic about the language, machine or kind of processor doing the work.




An application can span multiple computers and processor types. A worker may run on a CPU, another on a GPU or specialist device. Each implementation targets its own hardware; the document contract is what lets the pipeline connect them.
C# is used in the current prototype and proposed interpreter tooling. It is a starting point, not the boundary of the system.
Destination architecture, not a list of supported devices today. Connecting different machines and processors requires compatible adapters, transport and contracts; it does not make one binary run everywhere.
The proposed runtime has a place for entry, execution, storage and observation. Each has a clear job. This is the destination architecture, beyond the current UI prototype.
The arrows simplify the design. Only CRUD workers access the database; queries can use its lookups to find the source documents.
A screen is an interface into the work. So is another program. The goal is for both to reach the same underlying capabilities.
For a person, the interface starts with business words. Explore a word, narrow the context, and read the resulting documents. Clicking words and typing both build the request.
The current prototype explores this with a navigable word space, a query box, tables, cards and document views. Its query interpretation is deterministic.

A HELPING HAND FOR THE UNFINISHED PARTS.
Then help build its replacement.
AI has two roles in the intended system. It can transform a document at a defined step while a dedicated module does not yet exist. It can also help author the focused module that eventually replaces that transformation.
The business pipeline keeps its meaning as the implementation changes.

The business step declares what it receives and what it must produce.
Check the resulting pages before passing them to the next worker.
This is a planned runtime capability. AI transformations can vary; they are not made deterministic by being inside a pipeline. The step needs validation, defined failure handling and review where the business requires it. A schema check alone does not prove that a transformation is correct.
A business process describes the work we anticipated. Sometimes a person needs something done that the system was never programmed to do. That exception falls outside the process as designed, which is why systems so often refuse it. The need itself may still be valid.
The intended role for an AI module is to make that exception workable and visible: transform the document within the permitted workflow, and capture what was requested, what changed and the result. The exception becomes something people can review and learn from.
A user needs a result that the designed process does not yet cover.
The AI module transforms the document and records the exception, its context and its outcome.
Reviewers ask whether a new rule or module is needed, or whether this case has already been addressed.
Build the missing behaviour, or connect the exception to the existing solution. Keep the review decision with the record.
An exception should become evidence for improving the system, rather than disappear as an undocumented workaround.
A small worker with a clear contract is a bounded task for an AI coding assistant. It can propose an implementation, draft a pipeline or suggest an improvement. Acceptance depends on explicit checks and the review required for the change.
A worker, a pipeline description, a correction or a code change.
Only an accepted change enters the executable system. Failed candidates remain proposals.
✓ Checked change↶ Revise the proposal“AI may propose.
Only verifiers may dispose.”
Author, test, refactor and audit individual workers. People govern the rules and important structural decisions. Unit tests provide evidence; they are not a universal proof of correctness.
A proposed small client-side model could correct names in the query box. Suggestions must resolve to known vocabulary, stay undoable, and leave uncertain text alone. The deterministic query engine still runs the request.
When information moves through explicit hand-offs, an observer can be designed to record it. A failure becomes a specific document at a specific stage.
The ambition: replay captured inputs against a replacement worker in a separate test environment, compare the outputs, and catch regressions before promotion.
Planned capability. Capturing business data requires access controls, retention rules and redaction. Test runs must not send real emails, submit payments or repeat production writes.
CRUD and Logic is under active development. The interface is the first proving ground. The complete runtime described here is still a design to build and validate.
Development status documented in October 2026. This website explains the project; it does not provide access to the private prototype.
The design direction, not a claim that these runtime services are already operating.
Research ideas from the project discussions. No release dates or production guarantees are implied.
A Document contains Pages for a particular business flow. The design uses XML fragments as the Page envelope, with CDATA holding the payload. That payload could be JSON, XML, SVG, G-code or text encoding of binary data.
XML metadata identifies the page and its contract. A payload still needs validation appropriate to its own format; wrapping JSON in XML does not validate its contents. File framing, indexing, encoding and version compatibility remain design questions.
Small enough to understand and test on its own. A project rule of thumb is that a function exceeding roughly 60 lines deserves another look. The purpose is a focused responsibility, not winning a line-count contest.
Separate data access from business rules. Keep inputs, outputs and side effects explicit. The intended destination is assembly and other specialised native implementations, including bespoke hardware where useful. The system is language- and processor-agnostic; C# currently supports the prototype and proposed interpreter tooling. Small units can enable specialist contributions without exposing an entire application.
A pipeline consists of connected worker processes. Each executable worker receives a Document, performs a focused job and passes the Document to the next process. Workers can remain running to handle successive documents.
Memory-mapped files are the proposed local transport, with disk-backed options explored. Across machines, Homa / IP is an exploratory direction. The orchestrator connects and manages the worker processes. Their document contracts allow the wider application to span machines and processor types. Framing, back-pressure, ordering, correlation, retries and recovery still need engineering and measurement.
The proposed source of truth is the document file, kept under version control. The database holds statistics and lookup information that points back to those documents. Only CRUD workers touch the database.
The aim is inspectable history alongside fast discovery. It still needs a carefully designed write path: Version history alone does not solve multi-user transactions, concurrent edits, cross-document consistency or cache invalidation. Earlier ideas included linked documents, local read caches and reviewed changes through pull requests.
The familiar part is composing a flow. The ambition goes beneath the designer: the same small workers, contracts and observable hand-offs define how the software itself is assembled.
This needs a runtime, interpreters and operational tools as well as a visual interface. It is a research-led approach with real implementation costs. It has not yet demonstrated that it is faster, cheaper or simpler than existing app builders for every use case.
The long-term packaging preference is a configured virtual machine rather than Docker. The browser interface connects through a gateway; a desktop client is also being explored. The prototype uses Avalonia and WebAssembly with GPU-rendered drawing.
A VM is one boundary, not a complete security model. Authentication, authorisation, least-privilege worker access, signed updates, secret handling and protected observation data need explicit designs. Local communication does not make the internals automatically trustworthy.
A possible future service would analyse an application, identify focused functions and separate data access, logic and orchestration. AI could help propose that decomposition and create tests around the resulting contracts.
The discussions also explored maintenance services, reusable signed components, staged updates and a library discovered from existing code. These are commercial and research possibilities, not currently available products. Licensing, behaviour preservation and safe promotion would need checking.
The document idea could extend beyond orders. A robotics pipeline might transform a motion description into driver instructions while sensor documents feed defined responses. Simulation and replay could help analyse a plan before execution. No robotics safety capability is claimed.
A separate idea is AI-proposed code optimisation using C# intermediate language and a graph of known transformations. A candidate would require semantic verification and measurement before acceptance. This is future investigation, not the prototype's execution engine.
Actor starts the work. Document carries the context. Page holds one kind of information. Worker performs a focused job. Pipeline connects those jobs.
12 / The Direction
Business software that people can follow.
Small pieces that humans and AI can help build.
A system that remains testable even under production conditions.
I’ll tell you the day it’s real.
No spam, and no pitch. Unsubscribe whenever.