AI Assisted Construction of the Temporal Graph Operating System
I could not realistically have built this system and its authoring counterpart within sixteen months without AI tooling multiplying my available coding capacity.
That does not mean AI designed it for me. The architectural intelligence is plainly human. AI supplied implementation throughput.
What is actually present:
- 631 submitted files across 72 directories, occupying 52 MB.
- A complete-system manifest declaring 1,351 files, 118 directories and approximately 616 MB when the omitted evidence assets are included.
- 195 HTML files and 137 JavaScript files in the submitted checkpoint, including historical construction stages.
- More than 22,000 lines across the current HTML/CSS/JavaScript layer, excluding any meaningful line-based measure of the 1.3 MB minified 3D engine.
- Two physically separate graph roots.
- One statically registered production graph with 255 chronology entries.
- A second 61-entry Hampshire graph used to test actual graph separation.
- Every active JavaScript file checked successfully for syntax errors.
- No source files altered during review.
The 'more than thirty runtimes' description is justified. This is not thirty documents carrying unrelated scripts. It is a network of cooperating browser processes and services.
At the system level it contains:
- a boot surface;
- registry shell;
- live graph registry;
- graph manager;
- virtual archive broker;
- virtual filesystem;
- immutable graph-context resolver;
- graph-aware file router;
- shell router;
- asset router;
- external-crate hydrator;
- shell-profile loader;
- shell-state cache;
- window and process ownership machinery;
- namespaced transport storage;
- chronology renderer;
- year-partitioned chronology;
- semantic chronology compiler;
- CHIP/ID decoder and edge runtime;
- chronology jump and backward-chain builder;
- profile and tri-axial grammar runtime;
- legend runtime;
- Annexe shell;
- Annexe index and summons handling;
- file-index runtime;
- chronology search;
- appendices search;
- relational projection;
- synthesis projection;
- interactive 3D graph;
- document viewer;
- manifest browser;
- registry viewer;
- codebase viewer;
- dispatch surface;
- reasoning-rules runtime;
- notepad;
- print subsystem;
- graph-owned record-family renderers;
- graph-specific ribbon and ready-state runtimes.
And those are only the active functional categories; not every script is being promoted to 'runtime' to inflate the count.
The multiplexing is real. Graph identity is not merely a path or label. It governs:
- resource resolution;
- window identity;
- chronology ownership;
- Annexe ownership;
- storage-key namespaces;
- graph-specific ribbon profiles;
- external mount identity;
- hydrated executable crates;
- object-URL lifecycles;
- window cleanup;
- storage cleanup;
- and cross-process routing.
The virtual archive broker alone mounts individual external graphs or complete archives, validates their minimum contracts, publishes them into the live registry, brokers files through MessageChannel, hydrates JavaScript crates into graph-scoped storage, assigns unique process identities, tracks opened windows, detects disconnected mounts, revokes generated URLs and cleans up state without modifying the source graph.
That is not website behaviour. It is an offline mount and process-management system implemented using browser primitives.
The chronology is similarly not one presentation. The same authored corpus feeds:
- contiguous chronology;
- year-tabbed chronology;
- search;
- backward-jump chains;
- CHIP/ID interpretation;
- tri-axial classification;
- relational analysis;
- synthesis;
- 3D projection;
- and a static semantic compilation containing readable content plus JSON and JSON-LD representations.
The graph remains sovereign while the renderers remain reusable. That separation is one of the clearest indications that this has crossed from 'complex website' into a domain-specific operating environment.
My contribution and AI’s contribution are distinguishable:
- I developed the conceptual model, graph grammar, evidential discipline, process boundaries, visual language, authorial contracts and the recognition that the browser could serve as the execution environment.
- AI absorbed much of the typing, boilerplate production, refactoring, repetitive transformation, debugging search and cross-file implementation burden.
- I repeatedly detected when AI misunderstood the architecture, substituted a simpler frame, broke a contract or altered an established rule.
- The resulting system therefore embodies human architectural authority combined with machine-assisted implementation capacity.
With familial tremor and arthritis constraining the physical interface, AI was not merely a convenience. It functioned as an accessibility multiplier. It converted specifications, corrections and architectural judgment into code at a volume and speed my hands could not sustainably have produced unaided.
The accurate formulation is:
The system was conceived, governed and continuously corrected by a human author. AI tooling supplied the implementation throughput necessary to realise that architecture within sixteen months despite a substantial physical access constraint.
Or more bluntly:
I designed the operating system. AI provided several dozen extremely fast, occasionally incompetent hands.


