A project in the making · An idea worth exploring

Software.
Assembled.

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.

Start the field guide
CRUD & Logic / A visual field guideFrom Idea to ArchitectureAn artistic impression of documents in motion

You know the work.
Why keep rebuilding
the machinery?

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?

01

CRUD holds the data.

Create, Read, Update, Delete. Dedicated workers handle storing and retrieving information.

02

Logic does the thinking.

Check a quantity. Apply a pricing rule. Work out a delivery date. Each worker has a focused job.

03

Pipelines connect the work.

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.

One order.
A series of small jobs.

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.

ORDER PROCESSING / ILLUSTRATIVE EXAMPLE
STEP 01 / RECEIVE ORDER

The document starts the journey.

A person or a connected system supplies the order. This example begins with an order page and its line items.

Order document DEMO-1041
  • Order details
  • 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.

A tangible graphite and copper case file holds layered translucent pages, with incoming teal document sheets joining it
ONE TRAVELLING DOCUMENTThe context comes with it.

One envelope. Many kinds of information.

  • Order details
  • Line items
  • Validation
  • Pricing
  • Trace & errors

A travelling
case file.

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? ↘

Start with the way
your business speaks.

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.

ILLUSTRATIVE BUSINESS DESCRIPTION

“Receive the order.
Check its details.
Calculate the total.
Save and return the result.”

A conceptual example, not a released language syntax.
Domain interpreterRecognise → check → connect
CONNECTED WORKER PROGRAMS
Receive.exeValidate.exePrice.exePersist.exeRespond.exe

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.

What programming language?
As close to the metal
as the job needs.

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.

COMPUTER A
Intel Core i7-12700K CPU photographed from above by Eric Gaba
CPUx86 / AMD64 / Arm64Eric Gaba / Wikimedia ↗CC BY-SA 4.0 · resized
Google Coral Edge TPU accelerator module, cropped from Google’s product photograph
GPU / NPUParallel / tensor processingCoral Edge TPU / Google ↗
COMPUTER B
Efficient Computer Electron E1 processor, shown from the front and underside
Specialized ProcessorsRISC-V, Electron E1, FPGAEfficient Computer ↗
Tenstorrent Blackhole p100a PCIe accelerator board with its processor and PCIe connector visible
SuperCompute PCIeTenstorrent BlackholeImage: Tenstorrent ↗

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 flow is the centre.
The system supports it.

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.

PeopleDocument interface
+
Other systemsProgram interfaces
Gateway pipelineTurns a request into a Document · WebSocket connection for the browser
PIPELINE RUNTIME / CONNECTED WORKER PROCESSES
OrchestratorStarts and steers the pipelines
Receive.exeValidate.exePrice.exePersist.exeRespond.exe
ObserverDesigned to capture the journey for tracing and replay
Version-Controlled DocumentsProposed source of truth
Files with version history
DatabaseProposed statistics & lookups
References back to documents

The arrows simplify the design. Only CRUD workers access the database; queries can use its lookups to find the source documents.

Explore with words.
Get back 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.

Orders stays at the centre of an information space as translucent documents fan outward toward the viewer
CONCEPT ILLUSTRATION
Show today's pending orders

A HELPING HAND FOR THE UNFINISHED PARTS.

AI can bridge
a missing module.

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.

An articulated collaborative robot holds a miniature teal bridge in its gripper, connecting two separated platforms as document sheets travel across
THE MISSING PIECEA bridge while we build.
AI as a temporary connection, illustrated with a cobot lending a hand.
INPUT CONTRACT

A document arrives.

The business step declares what it receives and what it must produce.

SAME STEP / EVOLVING IMPLEMENTATION
First: AI transformationInterpret and transform the document
↓ Replace when the module is ready
Later: dedicated moduleA tested, specialised implementation
OUTPUT CONTRACT

Continue the pipeline.

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.

BUSINESS EXCEPTIONS / A PLANNED ROLE FOR AI

People wear in shoes.
They should be able to wear in systems.

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.

01 / ENCOUNTER

A need outside the script.

A user needs a result that the designed process does not yet cover.

02 / TRANSFORM & CAPTURE

AI handles the gap.

The AI module transforms the document and records the exception, its context and its outcome.

03 / REVIEW

Understand what happened.

Reviewers ask whether a new rule or module is needed, or whether this case has already been addressed.

04 / RESOLVE

Code it, or connect it.

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.

AI also helps build the pieces.

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.

PROPOSE

AI creates a candidate.

A worker, a pipeline description, a correction or a code change.

VERIFY

Check the contract.

  • Valid structure and types?
  • Expected behaviour in tests?
  • Declared access and side effects?
  • Required review completed?
DECIDE

Accept or reject.

Only an accepted change enters the executable system. Failed candidates remain proposals.

✓ Checked change↶ Revise the proposal
“AI may propose.
Only verifiers may dispose.”
AUTHORING / LONG-TERM DIRECTION

Smaller jobs for agents.

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.

INTERFACE / DESIGNED, NOT IMPLEMENTED

Helpful local autocorrect.

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.

See the flow.
Replay the evidence.

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.

LIVE WORKInput→Current worker→Result
↓ Copy captured input · isolate side effects
SEPARATE TEST ENVIRONMENTReplay→Candidate worker→Compare

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.

A working beginning.
A larger direction.

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.

CURRENT PROTOTYPE

Make the information usable.

  • Avalonia client for browser and desktop targets
  • Deterministic queries over order, vendor PO and route data
  • Word navigation and layered filtering
  • Tables, cards, document grids and PDF export
  • A Core separated from the presentation layer

Development status documented in October 2026. This website explains the project; it does not provide access to the private prototype.

PLANNED ARCHITECTURE

Connect the full runtime.

  • A gateway and a first executable pipeline
  • Business-language interpreters written in C#
  • Orchestrator, workers and observer
  • Version-controlled document files, lookups in a database
  • Local hand-offs, followed by distributed transport
  • AI document transformations until dedicated modules are built

The design direction, not a claim that these runtime services are already operating.

FURTHER EXPLORATION

Learn what the model enables.

  • Agent roles and checked software maintenance
  • Reusable worker libraries and code discovery
  • Breaking existing applications into smaller pieces
  • Recorded-input testing at larger scale
  • Assembly workers, mixed processors and bespoke PCIe devices
  • Robotics pipelines and verified code optimisation

Research ideas from the project discussions. No release dates or production guarantees are implied.

A little more architecture.
Without losing the thread.

What is inside a Document?+

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.

How small is a worker?+

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.

How do the hand-offs work?+

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.

Why version-controlled files and a database?+

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.

How is this different from an app builder?+

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.

Where does it run, and who controls access?+

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.

Can an existing application be converted?+

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.

What about robots and AI optimisation?+

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.

FIVE WORDS TO KEEP

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

Less hidden machinery.
More visible intent.

Business software that people can follow.
Small pieces that humans and AI can help build.
A system that remains testable even under production conditions.