# BigMachine

> BigMachine extracts structured engineering data from P&ID drawings. Upload a PDF; the system returns every piece of equipment, instrument, and process line as a queryable graph — with a bounding box and confidence score on every claim. Titan, the AI orchestration layer, answers natural-language questions by reading that graph, not the drawing image.

## Pages

- [Home](https://www.bigmachineai.com/): Product overview and key capabilities
- [Docs](https://www.bigmachineai.com/docs): Full user guide — upload, Titan Explorer, markup tools, API quickstart, example prompts
- [API Explorer](https://www.bigmachineai.com/api-explorer): Interactive REST API reference
- [Feature Tour](https://www.bigmachineai.com/feature-tour): Walkthrough of each major capability
- [Gallery](https://www.bigmachineai.com/gallery): Screenshots and screen captures from the live product
- [Use Cases](https://www.bigmachineai.com/use-cases): Bid preparation, commissioning, revision analysis, signal tracing, and more
- [Pricing](https://www.bigmachineai.com/pricing): Per-drawing-sheet pricing with Starter, Team, and Enterprise tiers
- [Security](https://www.bigmachineai.com/security): Deployment shapes, data residency, and architecture-level commitments
- [Integrations](https://www.bigmachineai.com/integrations): CAD, document stores, BI, ERP, and asset management connectors
- [Changelog](https://www.bigmachineai.com/changelog): Release notes for each version
- [Customers](https://www.bigmachineai.com/customers): Customer quotes and case studies
- [Blog](https://www.bigmachineai.com/blog): Articles on AI and engineering
- [Versus](https://www.bigmachineai.com/vs): BigMachine vs general-purpose LLMs
- [CLI](https://www.bigmachineai.com/cli): Command-line interface reference

## Product Overview

BigMachine processes P&ID drawings and turns them into structured, queryable data. You upload a PDF; the system extracts every piece of equipment, instrument, and process line from it, and you explore or query the results through Titan Explorer.

The extraction is deterministic geometric math — not an LLM reading the image. Titan, the AI orchestration layer, reads the canonical extraction graph in one query and answers questions, surfaces layers, and generates documents from that structured output. Titan never reads the drawing image directly.

Every claim is traceable to the source pixels with a confidence score and a bounding box. Nothing ships as an opaque output.

Every screenshot on the site is captured from the running product on real customer drawings.

## Titan

Titan is the orchestration layer — natural-language commands, instant answers, one-click workflows. When Titan answers, it is reading a structured engineering model built from static drawings.

What Titan does:
- Reads the canonical extraction graph in one query
- Surfaces the right UI tool — chart, overlay, or table
- Cites every claim with document, page, and bounding box
- Suggests rule edits so the system gets smarter on its own

Titan produces four output types: a text answer, bounding-box highlights on the drawing canvas, an interactive table in the chat panel, or both highlights and table together. Every answer includes citations linking to the page and item.

Example Titan prompts:
- "Show me all the equipment on this drawing."
- "List all control valves on unit 3."
- "What instruments are on loop FIC-201?"
- "Show 6-inch lines in sour service."
- "Check for duplicate tags."
- "How many vessels have design pressure above 150 psig?"
- "What connects to the suction of P-101A?"
- "Generate an equipment list I can export."
- "Compare this page with the previous revision."
- "Highlight all temperature alarms across the drawings."

## Core Extraction Capabilities

**Equipment extraction** — Every vessel, drum, pump, compressor, heat exchanger, and valve located and classified by geometric shape recognition. Each item has a bounding box, tag, classification, and confidence score.

**Line detection** — Every process line measured and cataloged. IDs, specs, and geometry extracted in seconds. Lines are bound to upstream and downstream equipment.

**Instrument extraction** — Every instrument tag, control valve, transmitter, and indicator located, typed, and linked to its loop.

**OCR and tag recognition** — Free text, annotations, and on-the-fly text extraction linked automatically. Tags are canonicalized and categorized.

**Signal chains** — Instrument loops reconstructed across the page. Control loops are a graph, not a vibes-based association. SignalTrace walks the spatial DAG edge by edge in deterministic order, citing the rule that bound each link.

**DAG reconstruction** — Equipment, instruments, and lines reconstructed as a connected network you can walk, trace, and query. The graph is queryable, traversable, and diff-able. Compare two revisions on structure, not pixels.

**Revision comparison** — Graphical diff between revisions surfaces only what matters to engineers. Changes are categorized as add, remove, or modify so engineering change orders arrive with the full picture of knock-on effects before they reach procurement.

**Drawing review** — Ask Titan to review for anything: duplicate tags, TBD left in design details, PRVs missing set points, valves missing a material spec, high-high alarms set below the high alarm. No hard-coded rules — the review is as broad as your spec.

**Document generation** — Generate data sheets, templated equipment lists, or build your own template and let Titan fill it from the structured extraction model. Bring your own template; Titan populates it from the extraction graph.

**Symbology extraction** — Ball valves, reducers, and untagged shapes located and visualized across all drawings. Symbology extracted, not just text.

## Why BigMachine vs General-Purpose LLMs

GPT-4o, Claude Opus, Gemini, and Copilot are excellent general models. None of them produce the five things a downstream engineering workflow needs: a reproducible answer, a pinpointed location, a real graph, and a confidence number that actually means something.

| Capability | GPT / Claude / Gemini | BigMachine |
|---|---|---|
| Reproducibility | Sampling introduces variance — different answer each run | Bit-identical output for the same input; no sampling in the extraction loop |
| Location precision | Approximate or absent | Pixel-precise bounding box on every tag, contour, and line endpoint; highlightable on the source |
| Graph structure | LLMs narrate graphs; connections are implicit in prose | Real directed graph built from contour adjacency; queryable, traversable, diff-able |
| Confidence scoring | A confident sentence with no mechanism to flag hallucinations | Per-extraction score from agreement, contour match, and graph support; sub-threshold rows routed to review |
| Drawing data | Reads the image directly | Titan reads only the deterministic extraction output; never reads the drawing image |

## API and SDKs

**Authentication** — API key bearer token sent in the `Authorization` header on every request. Keys are scoped to project and rotatable on demand. Enterprise customers can use mTLS client certificates with a corporate CA.

**Key endpoints:**
- `POST /drawings` — Upload drawing, returns `drawing_id`; indexing is asynchronous
- `GET /drawings` — List drawings, paginated, filterable by `project_id` and `status`
- `GET /drawings/{drawing_id}` — Drawing metadata, page count, revision
- `GET /extraction/equipment` — Equipment extraction payload per page
- `GET /extraction/instruments` — Instrument extraction payload
- `GET /extraction/lines` — Line extraction with geometry
- `GET /extraction/dag` — Full directed graph payload
- `POST /revision/diff` — Structural diff between two drawing revisions; returns added, removed, modified with bounding boxes
- `GET /titan/runs` — Titan session status, prompt, and citations

**HTTP status codes:**
- `200 OK` — Success
- `202 Accepted` — Job queued (upload, reindex, webhook)
- `400 Bad Request` — Malformed payload
- `401 Unauthorized` — Missing or invalid API key
- `403 Forbidden` — Key valid, wrong project scope
- `422 Held for Review` — Low confidence; needs review
- `429 Too Many Requests` — Rate limit
- `500 Internal Error`

**Webhook events:**
- `drawing.indexed` — Fired once; OCR, geometry, and DAG complete and fully queryable
- `extraction.completed` — Fired per page with equipment count, instrument count, and line count
- `revision.diff.ready` — Diff computed with added, removed, and modified items
- `confidence.below_threshold` — Extraction below confidence floor; needs review

**Official SDKs:**
- Python: `pip install bigmachine-sdk`
- TypeScript: `npm install @bigmachine/sdk`
- Go: `go get github.com/bigmachineai/bigmachine-go`
- Ruby: `gem install bigmachine`

**Python quickstart:**
```python
from bigmachine import Client

client = Client(api_key="YOUR_KEY")
drawing = client.drawings.upload("E001740-01-101.pdf", project_id="proj_01...")
print(drawing.id)  # "dwg_01HFW3..."
```

## Security and Deployment

Four deployment shapes, one extraction engine. Procurement picks the residency story that fits the policy.

**Air-gapped** — Deployed on your hardware, on your network. Zero outbound calls. Nothing reaches the public internet.

**Private cloud** — Deployed inside your AWS, Azure, or GCP tenant. You own the data, the network, the keys. BigMachine never sees the traffic.

**Hybrid** — Extraction stays on-prem. A thin UI plane runs in the cloud. Only metadata crosses the boundary — never drawings, never source PDFs.

**SaaS** — BigMachine hosts everything. Fastest path to production — no infrastructure work required. Suitable where on-prem is not a hard requirement.

Architecture-level commitments:
- Drawings never sent to OpenAI, Anthropic, Google, or any other foundation-model provider. The extraction stack is 100% internally developed.
- The geometric models and rule bundles are fixed at install time. Customer drawings never enter a training corpus.
- AES-256 on every database, artifact bucket, and extraction cache. Keys live in your KMS.
- TLS 1.3 everywhere. Mutual TLS available for service-to-service hops inside your VPC.
- Full purge of source PDFs, derived images, and extraction artifacts within 24 hours, certified in writing.
- SOC 2-aligned architecture. GDPR compliant for EU customers with in-region data residency.
- Role-based access control and SSO integration.

## Pricing

Pricing is per drawing sheet indexed per month (P&IDs, PFDs, ISOs) plus document pages (specs, datasheets, procedures). Annual prepay saves 20%.

**Starter** — Small EPC teams running 1–2 active projects.

**Team** — Mid-size EPCs managing approximately 10 active projects across a drawing portfolio.

**Enterprise** — Operators, mega-projects, and multi-site programs with custom residency requirements. Includes one custom integration per quarter.

All tiers include:
- A structured session to align on success criteria before a single drawing is uploaded
- Hands-on user onboarding
- 30-day pilot: full tier access on your drawings and data, every output included
- A closing review against the criteria set at kick-off

Overage: billed at the per-drawing rate of your tier; alert at 80% of limit.

## Integrations

**Ingestion paths (8):** CAD authoring systems, plant model repositories, document stores, engineering record systems, and tag databases.

**Export paths (8):** ERP, data warehouses, BI dashboards, asset management, and operational notifications.

Direct extraction tables are queryable in SQL. One bidirectional pipeline — inputs flow from your CAD and document stack, outputs flow back to BI, APIs, and downstream tools without re-keying.

Python and TypeScript SDKs wrap the REST and webhook surface. Stream extraction events, query feature runs, push annotations — same auth, same auditing, no new infrastructure.

Enterprise customers get one custom integration per quarter.

## Customer Quotes

- "Cut our P&ID redlining time from days to hours. The math is checkable — every flag has a confidence score and a bounding box."
- "Revision tracking that doesn't miss a delta. We caught a flange-rating change on rev 4 that would have made it into procurement otherwise."
- "The commissioning packets generate themselves. Valve and instrument inventories with traceable evidence per tag. Full audit trail, no black boxes."

## Titan Explorer

Titan Explorer is the main workspace. The left panel is the chat pod where you talk to Titan. The right side is the drawing canvas. Work across the full project — multiple drawings open, multiple Titan sessions running, each scoped to its own context.

Spatial awareness is built in — ask about any valve or instrument and Titan answers and shows you exactly where it is on the drawing. All associations are captured automatically — design conditions, specs, and classifications linked so Titan can reference them in any review.

Save and share any session — drawing, layers, and full Titan conversation captured so anyone on the team can pick up where you left off.

## Document Repository

Upload PDF drawings via drag and drop. Supported formats: PDF, PNG, JPG. Multi-page files supported. Max file size 500 MB, max 200 pages.

Indexing stages: queued → indexing → indexed. Status updates live in the drawing list.

Revision tracking: upload a new revision, compare revisions. Include the revision in the filename (e.g., "E001740-01-101 Rev 2.pdf") so the revision history stays readable in the drawing list. The repository auto-pairs revision sets, detects rev letters from filenames and title blocks, and kicks off indexing in parallel.

## Research: The Extraction Stack

The proprietary math behind the extraction. Three OCR engines reconciled per page. Contour math against a canonical symbol library. Spatial graph reconstruction. Every claim auditable.

The full stack: Postgres at the centre — PostGIS for geometry, pgvector for embeddings, pgRouting for flow networks — three OCR engines reconciled per page, FastAPI in front, Playwright watching the door, and Titan on top.

### Three-Engine OCR Fusion

Engineering drawings break general OCR — raster artifacts, rotated tags, tiny callouts, dense regions. BigMachine runs three independent engines per page and then fuses the results:

- **pdfplumber** — Fails on scanned and rasterized P&IDs; finds nothing if the PDF has no embedded text layer.
- **Tesseract** — High recall on rasterized pages but fragments at the character level; needs fusion to recover tags.
- **Google Vision** — Highest recall, word-level grouping, but susceptible to rotation artifacts and dense-region merges.

On real plant drawings, only a small fraction of tokens are seen by all three engines. That sliver is where the deterministic answer lives:

- **All three engines agree** → locked as high-confidence
- **Exactly two engines agree** → passes the fusion gate, scored ~0.85–0.95
- **Single-engine fragments** → only kept if a fusion rule recovers them

### Contour Matching

A typical project uses approximately 50 symbol shapes — far below the data floor of any image classifier. BigMachine indexes a canonical reference library once, then matches every contour on every drawing against it by rotation- and scale-invariant distance.

From the legend page or a curated library, every symbol is digitized into a canonical contour with rotation and scale invariants attached. Matching is deterministic — no learned weights, no sampling temperature.

### Spatial Graph Reconstruction

The line network reconstructs the directed graph of signals and process flow. The spatial network is assembled by spatial reasoning over contour endpoints — a procedure with no learned weights and no sampling temperature.

Every edge carries the evidence it was assembled from. Strip the JSON, replay the evidence, and you can independently re-derive the topology. No model in the loop.

The graph is the output of spatial joins on contour endpoints and tag bounding boxes.

### Confidence Scoring

The fusion layer composes per-engine OCR agreement, contour-match distance, and spatial network support into a single confidence score. The distribution is heavily skewed toward 1.0 — but the small middle band is what keeps the system honest, and the tail is what humans look at before anything goes downstream.

Score bands:
- **High (passed)** — Two-tool agreement or partial network support. Flows downstream automatically.
- **Review** — Single-tool fragment without geometry support, or contour-distance above threshold. Surfaced to a reviewer with the failure reason attached before downstream consumers see it.

Score components:
- **Contour distance** — Distance against the canonical reference contour, normalized for rotation and scale.
- **Network support** — Does the surrounding line topology corroborate the tag? Orphan tags lose support.

### Titan's Architecture

Titan is an AI agent that runs on the extraction graph — not the raw drawing. Its answers are bounded by deterministic math. As the graph grows, Titan gets smarter automatically.

Architecture layers (top to bottom):
1. **Titan** — Frontier model, domain prompts, tool routing. Chains APIs to plan, retrieve, and assemble engineering deliverables. Never reads the raw drawing.
2. **Extraction graph** — Equipment, lines, instruments, confidence scores. Structured, deterministic, fully auditable. The world model Titan reasons against.
3. **Raw drawings** — P&IDs, UFDs, electrical one-lines. Raw input. Titan never touches these directly.

Example Titan tools (surface expands with the graph):
- Filter equipment by type, attribute, service code, or spatial relationship against the extraction graph
- Compare two graph states — returns adds, removes, modifications, and moves, categorized and confidence-scored
- Produce a marked-up drawing layer from query results — polygons, highlights, and annotations tied to source bboxes
- Assemble a deliverable (equipment list, data sheet, line list) from graph data into a user-supplied template
- Propose a classifier rule edit based on a pattern Titan observed — staged for human review before it takes effect

### The Core Claim

We don't ask a language model what the drawing means. Three OCR engines reconciled per page. Contour math against a canonical symbol library. A real spatial network. A confidence number on every extraction. Every claim traceable back to the pixels it came from.

If you open drawings today to look something up, Titan can answer that question. Every discipline, every phase of the asset lifecycle — no custom modules, no bespoke UI.

## Customers: Use Cases in Depth

Pulled from production deployments across EPCs, facility operators, and industrial service companies. BigMachine keeps delivery on schedule, catches problems before they compound, and gives every discipline a shared, traceable view of the project.

### Multi-Discipline Revision Review

**The problem:** Rev 4 dropped with 47 updated sheets. Controls, process, and mechanical all touched something — and each discipline needed to figure out what the others changed. Two days of manual comparison per revision cycle, and a 300#/150# flange rating change still made it into procurement. Billing the client for revision scope was approximate at best.

**What BigMachine does:** Diffs the revisions and categorizes every change: add, modify, move, remove. Controls filters to loop changes. Process sees spec deltas. The HAZOP team gets a traceable list instead of a coordination meeting. Procurement sees material changes with source drawings attached.

**Outcome:** Revision review from two days to a morning. Every flagged change comes with page, bounding box, and before/after values — enough for each discipline to close their items directly. Change order billing finally has an audit trail.

> "Revision tracking that doesn't miss a delta. We caught a flange-rating change on rev 4 that would have made it into procurement otherwise."

### Commissioning Packet Generation

**The problem:** Every commissioning handover starts the same way — rebuild the valve list, the line list, the instrument inventory by hand, from the drawings. Three weeks per unit, minimum. Errors from the last project's template copy into this one.

**What BigMachine does:** Generates the packet directly from the structured extraction. Every valve, line, and instrument pulled automatically, with source drawing, page, and bounding box. Field engineers tap a tag to open the source page.

**Outcome:** Packets generate in hours. Field engineers arrive with a traceable inventory per tag instead of a static PDF stack. New revision: the packet regenerates. Nothing carries forward from the last project.

> "The commissioning packets generate themselves. Valve and instrument inventories with traceable evidence per tag."

### Drawing QC at Full Coverage

**The problem:** A 12-inch isolation valve on an 8-inch line — found at the spool shop, not at QC. The process was discipline walkthroughs: engineers combing sheets by hand, building their own flag lists. There are simply too many things to check for any team to catch everything: spec breaks, orphaned instruments, missing connections, BOM discrepancies. Something always slips through.

**What BigMachine does:** Titan audits the full drawing set — every sheet, every spec relationship, every instrument parent check. The engineering team directs the review; Titan handles the coverage no walkthrough can match.

**Outcome:** That size mismatch would have been flagged on sheet 14, with the conflicting sizes and a bounding box. Complete coverage across the drawing set — not a walkthrough. Every finding prioritized, traced, and closeable.

> "Titan checks every sheet while I direct the review. We caught a size mismatch that would have made it to the spool shop — flagged, traced, closed in an afternoon."

### Bid Preparation from Stacked P&IDs

**The problem:** Stacked P&ID sheets requiring manual reconciliation. BOM accuracy ±2%, 142 items reconciled by hand.

**What BigMachine does:** Equipment lists, line lists, and instrument indexes extracted automatically from the drawing set with every item traceable back to its source page. Field-ready, traceable per tag, exportable as JSON or XLSX.

**Outcome:** Faster delivery, safer handovers, every team in sync. Prevented rework on a single project. Every output backed by the same traceable extraction.

## Contact

We will walk you through a live demo on real P&IDs — equipment extraction, model bindings, and spec breaks with a confidence score on every claim. No slides, no pitch deck. Response within one business day.