Atlas-Platform — a digital twin of your machine's documentation

The problem

When your machine goes down,
finding why shouldn't take longer than the repair.

A tripped breaker, a dead solenoid, a limit switch that stopped reading — once found, fixes like these take minutes. What takes the hour is the hunt: which breaker, which wire number, which page of which manual, and is there a spare on the shelf. The knowledge exists — trapped in thousands of pages of scanned schematics, cable lists, terminal-box drawings, and parts catalogs that only your most senior people can navigate. Every retirement takes that navigation skill out the door.

Most of MTTRis diagnosis — and most of diagnosis is documentation search, not wrench time.

1,000s of pagesper machine: schematics, wiring diagrams, cable lists, PLC references — often bilingual, always cross-referenced by convention.

Zero toolsserve the 2 AM moment. CAD serves design. CMMS serves work orders. Document management serves storage. Nobody serves the answer.

CAD & EDA

Serves design, not diagnosis

CAD understands drawings it authored — native files, current revisions. A twenty-year-old machine arrives as scanned paper: no source files, no symbol library, no way in. Redrawing a 200-sheet schematic by hand is months of error-prone work nobody budgets.

Document management

Serves storage

DMS and PDM systems file the PDF, version it, and find it by name — some even search the text inside. What none of them do is turn what's inside into structured, queryable data. The question that matters at a dead panel is not a document search.

CMMS / EAM

Serves the work order

Maintenance systems record that a repair happened, who did it, and what it cost. The diagnostic knowledge — which breaker, which wire, which page — lives outside the system, in binders and in the heads of people who retire.

Generic AI doc tools

Serve summaries

Chat-with-your-PDF produces text about documents — unanchored, re-read from scratch on every question, and prone to choking on dense engineering schematics. An answer without a source page is a liability at a live panel.

Four adjacent tools, four different masters — and none of them turns what's printed into data. That gap is the product.

The gap

Nothing on the market today can ingest hundreds of legacy PDFs behind your production line and output Certified relational data, a queryable graph, and a 3D reconstruction — with every fact traceable to the mark it was printed on.

Atlas-Platform is built to be that software.

Document extraction workbench: three draft tables — terminal boxes, connections, components — with live rows extracted from a wiring document, each awaiting human certification

Relational data — a terminal-box document becoming three draft tables: a thousand-plus connection rows extracted, every table waiting on a human's Certify.

Relations board: ten extraction-table cards wired field-to-field with glowing join edges and live match-rate pills

The queryable graph — every extracted document becomes tables on the board, wired to the others by the identifiers the pages already print, with live match-rates.

3D machine graph: three schematic sheets auto-assembled in dark space, continuation conductors riding harness-routed ribbons between them

The 3D reconstruction — three sheets re-assembled from the data alone, continuations riding the harness.

The core idea

Extraction with provenance so complete,
the data can redraw the drawing.

Most of the "AI reads your PDFs" tools on the market produce summaries — text about the document. Atlas-Platform produces the document's contents as structured data: every component, terminal, wire, cable, and table row, each anchored to the exact page and position it was printed on. The electrical drawing becomes a graph — components as nodes, terminals as ports, wires as edges — and the fidelity test is unforgiving: if the data couldn't reconstruct the schematic, the extraction isn't done.

Anchored, not paraphrased

Every extracted fact carries its source: document, page, position. Ask where a value came from and the answer is a place on a drawing, not a model's recollection.

The drawing stays the authority

Source PDFs are sealed evidence — never altered, never redrawn. The structured layer sits on top of the original print, so every claim remains checkable against it forever.

Reconstruction as proof

Because the graph preserves geometry and connectivity, the schematic can be rebuilt from the data alone. That round trip — paper to data to drawing — is the fidelity standard the whole platform is held to.

See the whole document at once

The machine's schematic, assembled in one 3D space

The machine graph renders annotated sheets as a single navigable scene — every sheet a slab, every component a solid, every conductor colored by its electrical role. Nothing here is a picture — every block and wire is the extracted data itself, re-rendered. The reconstruction proof, live.

The drafter's "continues on sheet 5" callouts resolve into real conductors that arc between sheets, routed like a physical cable harness: parallel wires ride one ribbon, turn at right angles, and steer around the sheets themselves. Grab any sheet and slide it where it connects — the wires follow. The deck grows as sheets are certified; next on the bench, a queried circuit lifts free of the deck and rebuilds in electrical order.

Machine graph: multiple schematic sheets rendered in one 3D space, components as solids, conductors colored by net class, continuation wires arcing between sheets

Live capture from the platform — four annotated sheets of a 200-plus-sheet schematic, and growing AC phase · DC rail · Earth · Control · Unlabeled

Machine graph with four sheets auto-assembled side by side, ten continuation conductors routed between them as right-angled harness ribbons through open space

Cross-sheet continuations, resolved — four sheets auto-assembled, ten conductors riding harness-routed ribbons between them the extension IS the wire

Why this shape

Two years of experiments taught us:
the answer isn't a bigger model.

Before Atlas-Platform was software, it was a team of maintenance engineers logging downtime — year after year, machine by machine — and a series of honest experiments in driving it down.

An AI notebook per line

Feed every manual into an AI notebook and ask it questions. Fine for overviews — but on a specific fault it answered no better than a web search. Depth was the whole point, and it had none.

Cache the whole corpus

Load every page into a frontier model and let it reason per question. The answers were real and factual — and each one took 10–20 minutes and cost as much as re-sending every page image with every question. Right answers, unusable economics.

Extract once, query forever

Move the heavy reasoning to ingestion: extract everything into tables and a graph with provenance, once per document — then compose already-extracted facts at query time. Answers in seconds, quoting their sources. That bet became Atlas-Platform.

The platform

Four surfaces, one engineer, one truth

Four working surfaces and one resident AI engineer — all running against the same Certified data layer. Build it on one surface, see it on all of them.

Author

Smart Canvas

The platform annotates your schematics and drawings at your direction — components become nodes, wires become edges with their printed labels — extracting the drawing into data that joins with the data from the rest of your machine's documentation. The Smart Canvas is where you view, step through, and edit anything in the annotations, every one anchored to the original print beneath.

Extract

Extraction Studio

Tabular documents — cable lists, terminal-box wiring, parts catalogs — become tables that mirror the printed page, row for row. Arc extracts page by page; a human verifies; Certified tables seal read-only with provenance to every row.

Visualize

3D Machine Graph

The whole document set in one scene: sheets as slabs, circuits spanning them, conductors colored by net class. The fastest way a human can see how a 200-plus-sheet machine actually hangs together.

Relate

Schema & Relations

Documents join each other on the identifiers they already print: wire labels to PLC I/O addresses, cable numbers to terminal boxes, part numbers to inventory. Atlas-Platform describes those joins once and every query after that walks them.

Assist · Arc, the AI Industrial Engineer

The resident engineer on every surface

Arc reads your pages, drafts your data, and learns your plant's conventions — governed by a rulebook of 260+ codified extraction lessons and a hard boundary: a human certifies, or it isn't truth.

Smart Canvas: a Certified schematic sheet with its logic-graph overlay — components, terminals, and wires annotated over the original print, Arc's panel docked at right

Smart Canvas — a Certified sheet. The overlay is the logic graph: components as nodes, terminals as ports, wires as edges, each snapped to the printed geometry beneath.

Smart Canvas mid-session: a dense annotated power sheet with its certification badge, and Arc's panel narrating a continuation fix, codifying the lesson, and running the audit clean

Arc mid-session — a fix applied, the lesson codified for future sessions, the audit read clean, and the founder's reply seals the page. Two pages certified in one exchange.

Extraction Studio: Arc designing a cable-list table live — a tabular document page at left, draft tables with typed columns building below

Extraction Studio — Arc designing a cable-list table live: columns proposed from the print, the table's schema taking shape below, the whole exchange costing under a dollar.

Relations board: four document schema cards — two cable lists, the schematic, a parts list — joined field-to-field by glowing edges through junction pills

Relations — documents joined on the identifiers they already print: cable lists, schematic, and parts list wired field-to-field into join contracts.

At production-line scale

Ingest the whole line. Query it like a database.

One machine is the proving ground; the design is for your whole floor. Every one of your machines' schematics, cable lists, terminal boxes, parts catalogs, and PLC references in one queryable digital twin — so a question that spans documents gets answered the way your line was wired, not the way anyone remembers it. At your direction, your plant's own records can join the twin — parts inventory, machine downtime history, manufacturing data — so recurring failures surface as patterns instead of anecdotes, and probable root causes come backed by what has actually happened before. Retrieval is evidence-based: answers come from extracted, Certified facts with the source page attached. If it isn't printed in the documentation, Atlas-Platform doesn't assert it.

fault: "actuator 2 not returning"→LS-207→wire 7204→CAB-64→TB-24 · slot 22→PLC X0921→spare · bin 5-K

The shape of a real trace: device → conductor → cable → terminal box → PLC input → shelf. You bring the fault and name the suspect device; from there, every hop is a printed fact with a page number behind it — a documented table or geometry lookup, never model inference, so the answer is auditable line by line. A recent live example: an unlabeled component on a wiring diagram was identified in two queries by searching the corpus text layer — its caption lived on a distant sheet of a different document, and the join agreed with the extraction exactly.

Request early access

How it works

From paper trail to digital twin

Ingest everything

Schematics, cable lists, terminal-box wiring diagrams, parts catalogs, PLC references — native or scanned, English or bilingual. The twin is built from your documents alone — nothing connects to your machines or your control network. The source document is sealed evidence; Atlas-Platform never alters it.

Extract, faithfully

AI extraction at the document's own grain, exactly as printed — governed by codified rules for what a blank cell means, when a table splits, and why a join key is never invented.

Certify with a human

Extraction is verified against the print by a person, then sealed read-only behind an append-only, checksummed archive — tamper-evident: if Certified data ever drifts afterward, an alarm trips. Certified is a defined trust tier: every row traceable to its page, every table either human-verified truth or clearly-labeled best-effort.

Query your machine

The result is a relational + graph twin of your machine's electrical reality, exactly as documented. Working today: a mystery designator resolved across the whole corpus in two queries. Next: circuit-trace and find-the-spare — the same Certified data layer, built to answer in seconds, with sources cited.

Under the hood

The right tool for every layer of the page

Industrial documents are hostile territory: vector CAD exports next to 40-year-old scans, original-language subtitles under mistranslated English headers, conventions that change mid-page. Atlas-Platform layers its methods to match.

vector & text-layer analysis

Where the PDF carries real geometry, Atlas-Platform reads it directly — text with coordinates, lines as lines. One machine schematic's vector layer alone carries over 100,000 printed primitives, each readable as exact geometry: "is this wire on that terminal" becomes arithmetic, not eyeballing.

OCR

Where scans are all that survives, optical recognition brings the text layer back — bilingual by default, matching the reality of decades-old imported machine documentation.

symbol fingerprinting

Pattern recognition over the drawing's native vector geometry — the exact shapes the CAD tool drew, not a scan of them. Label a symbol once and every instance across the drawing set is found, tolerant of rotation and mirroring. In proving runs a single hand-marked example located its siblings across pages in seconds, matching the human's box to within one pixel.

detection models

A vision detector trained on industrial drawings proposes component locations across 55 symbol classes. Proposals are evidence with a hard ceiling — they inform Arc and the human, and are structurally barred from gating or blocking any result. A detection means "look here"; the absence of one means nothing.

AI extraction agents

Model-driven readers that work page by page under a codified rulebook of extraction doctrine — 260+ lessons distilled from real extraction sessions and locked in. The model routes and inspects; for recognized document families, deterministic code emits the rows.

relational + graph store

Tables where the document is tabular, a graph where it's a circuit — queryable together, with the joins between documents modeled once and reused by every question.

human certification

The layer that makes it trustworthy

Page-by-page human verification, sealed tables, and an explicit trust tier on every dataset. AI drafts; people certify.

Arc · AI Industrial Engineer

Arc learns the job —
and never grades its own homework.

Arc is not an AI wearing an engineer persona — it's an engineer that learned by working: hundreds of supervised sessions on real industrial documents, every correction certified and retained as files in its memory — knowledge no prompt could fake, readable by any human. Resident in every surface of the platform, it reads your pages, drafts annotations and tables, and works under a rulebook built from its own history. What makes it different isn't just what it knows — it's what it is structurally forbidden to do.

It learns durably, on the record

Work sessions are mined for lessons: candidates are extracted by one model, then attacked by a second whose only job is refutation — and only a human certifies survivors into law. 260+ lessons have been codified this way, and a certified correction changes behavior the very next session with zero deploy. A lesson's supporting quote must trace to words the human actually typed; a paraphrase is rejected outright.

It cannot certify itself

Everything Arc produces stays a draft until a person verifies it against the print. Certified tables seal read-only — Arc's own write tools refuse them, and so does the API. A "done" claim is mechanically refused by the server while any open issue remains, and after every edit Arc must judge the result from fresh pixels before it may say "fixed."

It heals the platform

Every change Arc makes to its own platform lands on a branch, journaled, behind a kill-switch the founder controls — and ships only through a blue-green deploy: a complete copy boots in parallel, proves it serves, and only then does the cutover happen. The guarantee is tested, not promised — deliberately broken code was pushed through the pipeline and the live platform never flinched. That is what lets Arc sense regressions, read its own logs, and fix its own code — never your documents, never your Certified data — without ever betting the platform on it.

Trained in the standards your machines were actually built to: JIS & JEM electrical drafting · Japanese sequence-diagram conventions · Mitsubishi MELSEC-Q and Omron SYSMAC PLC programs, comments, and cross-references · FL-net multi-vendor networking · IEC 61131-3 ladder in both vendors' dialects · bilingual English/Japanese documentation — plus the unwritten shop conventions no standard ever documented. It reads the schematic, both PLC programs, and the network that ties them together — and cites the page for every answer.

The laws · held to the print

Rows are the print's;
columns are ours.

On the market today, every AI-extraction product asks you to trust its model. Atlas-Platform is built the other way around: the AI works under laws that hold it to the print — enforced in code, carried in every agent's instructions, auditable against the page. The first of them is the Grain Law: a table's rows only ever mirror what your document enumerates — lay any extracted table beside its page and it matches row for row, always. Everything the platform learns lands as columns, and every derived column cites the printed evidence it came from. AI can enrich your data; it can never invent a row your print doesn't show.

Faithfulness

The page is the audit

Values are captured exactly as printed — misspellings, duplicates and all. The data never "cleans up" the truth, because a corrected value is one you can no longer check against the source.

Total coverage

Nothing left behind

Every page is swept to completion — unneeded data beats missing data, and anything left uncaptured is left with a stated reason, on the record.

Human certification

AI drafts. A person seals.

AI output stays a draft until a person certifies it against the print. Certified tables seal read-only — the platform refuses every mutation, from the AI or anyone else, until a human deliberately unseals.

Evidence-ruled joins

Proposed with proof, ruled by you

Relationships between documents are measured against the live data before they become law. The AI proposes with the match evidence attached; a person rules — and a wrong link never silently enters the twin.

The proving ground

Proven end to end — on a real-world corpus,
not a toy dataset

Atlas-Platform is proven against a complete industrial documentation corpus — thousands of bilingual pages, scanned and vector, cross-referenced by convention, exactly as machine documentation actually ships. Proven, here, means human-certified: every sealed row verified against the print by a person.

60+documents in one machine's corpus — schematics, wiring, manuals, parameter lists, parts

2,700+pages of documentation in that single machine's corpus

200+sheets in the schematic alone, joining the 3D scene as they're annotated

1,200+conductors extracted from a single cable list — every one human-verified

2,800+Certified rows sealed so far: cables, wires, terminals, parts

260+codified extraction lessons — mined from real sessions, adversarially verified, human-certified

Seconds to resolve a mystery designator across the whole corpus — two queries, live today; the same answer once meant an hour with a binder.

Spare on the shelf? built to answer it at the panel — joins your stock and replacement-parts inventory to the drawings for part availability and possible substitutions, no trip to the stock cage.

While fighting my own repair times as a maintenance engineer, I found that almost all of the time was spent locating documentation and understanding the situation — not turning wrenches. The physical fix was fast. Finding which solenoid, which wire number, which page of which manual was the slow part. Fix the documentation problem and you fix the whole metric. That's Atlas-Platform.

— Founder · maintenance engineer, 20+ years on the plant floor

When your machine goes down,finding why shouldn't take longer than the repair.