TagIQ · technical overview

How it is built, and where the guard rails actually are.

The companion to the business overview, for the people who have to approve it. The claims made there — reads are pulls, a person approves, every write is attributable and reversible, one project cannot see another — are all enforced somewhere specific. This document is where.

RuntimeASP.NET Core 8minimal APIs, 184 routes across 31 endpoint modules
StorageEF Core · SQLite42 entity sets; on-line backup; provider-swappable
Live updatesSignalRone hub, project-scoped broadcast
ModelYours to chooseany OpenAI-compatible endpoint — hosted, your tenancy, or on the plant network
FrontendVanilla JSno build step, no framework, no bundler
Part one

Shape and deployment

Deliberately small. The whole thing is one process, one file of state, and a folder of static assets — which is what makes it deployable inside a plant network where nothing may call out.

Footprint One process, one database file A single ASP.NET Core host serving both the API and the client. No message broker, no separate worker, no container orchestration required to run it.
Frontend No build step Plain modules served as files. Nothing is transpiled or bundled, so what is deployed is what was reviewed — and a customer's security team can read it.
Egress Two outbound calls, both optional The model endpoint, and whatever export target is configured. With neither configured the application runs read-only and never leaves the network.
Browser reach The client never calls a source system Source fetches are proxied server-side, so CORS and browser-held credentials are never in the path. The browser only ever talks to TagIQ.
Documents Rendered in the browser, not converted Drawings and models are parsed client-side. No CAD seat, no conversion service, and no third party receives the drawings.
Model dependency Not on the critical path Import, validation, scoring, the punch list, export and sync are all deterministic code. The model is used where judgement helps; nothing structural waits on it.
Part two

The data model

A register that only holds rows cannot answer the questions a handover turns on. The spine is that every tag is a kind of thing that belongs to something, and that documents and connections are first-class rather than attachments.

ConceptWhat it carries, and why it matters
Tag classEquipment, instrument, loop, pipeline, piperun, piping component. Drives the naming rule, the required-property set and the required-document set. A tag with no class drops out of every completeness measure — so classification is a validation, not a label.
ParentA piperun belongs to a pipeline; a component hangs off its run. Naming rules can build a child's number from its parent, and an isometric is named after the run rather than the vessel.
AliasThe source identifier, kept forever. Reconciliation matches on name or alias, which is what makes a bulk rename survivable and is the single most load-bearing column in the schema.
AttributesPer-class typed properties with value lists, so a project's own vocabulary is data rather than a code change.
DocumentsControlled number, revisions, and the formats it was issued in — the viewable sheet, the CAD original, the raster, the native file — as one document, not four attachments. Tag links carry a role: appears-on, defined-by, modelled-in.
Ports & connectionsThe connectivity graph read from P&IDs. Every edge records the drawing that asserted it, so a connection is a traceable claim rather than institutional memory.
RequirementsWhat each class must have, by project phase, cumulative. The punch list is generated from this rather than compiled by hand.

Naming conventions are per class, built from segments — attribute, fixed text, sequence, parent name — each with padding, casing and separator rules. One project-wide pattern was tried first and could not express a register where a piperun, an instrument and a component all number themselves differently.

Part three

Ingest

Everything enters through the same pipeline, whatever the source, and nothing is committed before it can be seen.

01 · FETCH Server-side REST with bearer / basic / API-key auth, or CSV, XLSX, JSON. Proxied by the server, so no CORS and no credentials in the browser.
02 · MAP Transform expressions map(), split(), case and friends turn foreign columns into typed fields. The model can propose the whole mapping; the expressions it writes are inspectable and editable.
03 · PREVIEW Before commit Rows render as they would land. Name corrections are proposed with a confidence and a reason, and applying one writes the old name to the alias.
04 · RUN A revertible unit The import is recorded as a run. If the merge was wrong the register goes back to what it held, rather than being unpicked by hand.
Drawings DEXPI Proteus XML Equipment, nozzles, piping segments and their connections are read from the P&ID itself — matched by local name so namespace variants both parse. It resolves against the register read-only first, and reports what it could not read rather than silently importing less.
Reconciliation Matched, drifted, only-here, only-there Any second source — the owner's extract, a revamp package — is compared field by field on name or alias, and only the disagreements are reported.
Units Conversion that refuses to guess Deterministic, and pressure carries its reference: an unqualified pressure will not silently become gauge or absolute, because that inference is how a number becomes wrong in a way nobody notices.
Part four

The agent, and the rails it runs on

A tool-calling loop over a set of governed tools. What makes it usable near master data is not the model — it is that the rules live in the server, so they hold the same way for every request, however it is phrased.

Loop Plan, call, observe, repeat It reads the request, calls a tool, looks at the result and decides again. Every step is streamed to the client as it happens, including the ones that failed and what it did next.
Reads A live query, not a recollection A filter grammar for ordinary questions and read-only SQL for the rest — validated before execution, with writes and unknown tables rejected outright.
Project scope Guaranteed at the query Every statement touching project data resolves to a single project, checked server-side with its own unit tests. That one property is what lets competing contractors, licensor scope and client registers safely share an instance.
Writes Resolved before they are offered A queued write is executed against untracked copies using the same field logic the real write uses, so the approval card shows the actual diff and cannot drift from the outcome. A truncated preview says so, and withholds row-level selection rather than let someone approve rows they never saw.
Autonomy Three positions, server-enforced Read-only, ask-before-changes, autonomous. In the middle position a write is queued and nothing reaches the register until a person approves it — and a partial approval is rebuilt as a narrower write, not a filtered pretence of one.
Memory Against the project Conventions taught once are stored on the project rather than the conversation, so the next session — and the next engineer — starts with them.
Tools 29, in two halves Readers — statistics, filtered queries, read-only SQL, the delivery log, the document and connection graph. Writers — update one tag, bulk update, a where/set plan, lifecycle transitions, publish an artifact, revert a run. Each is a declared schema the model fills in, not free-form text the server parses.
Bounded A run cannot wander Twelve steps to a turn, fifty tags in a bulk update, five hundred under a where-clause, ten steps in a plan. The ceilings exist so a confused turn stops and says so rather than working its way through a register.
Context discipline Results are trimmed, not truncated blindly Tool results are capped and older ones summarised as the turn grows, so a long run stays inside a sensible window. That is what keeps a smaller, self-hosted model viable rather than only the largest hosted one.
Streaming Server-sent events Steps, results, approval cards and the final answer arrive as they happen over a plain SSE stream — no websocket for the agent, and nothing buffered until the end.
Failure A refused call is information A rejected filter or an out-of-scope query returns the reason to the model, which reads it and tries a different route. Refusals are part of the loop, and they are visible on screen rather than hidden.
Two model roles Set independently One model for the agent's tool calling, another for one-shot work like mapping suggestions and summaries — so a strong tool-caller can drive the agent while something cheaper handles the rest.
PORTABILITY · 01 One standard interface The client speaks the OpenAI chat-completions and tool-calling contract. Nothing above it is provider-specific.
PORTABILITY · 02 Three settings AI_BASE_URL · AI_MODEL_TOOL_CALLING · AI_MODEL_DEFAULT — endpoint and both model roles, by configuration.
PORTABILITY · 03 Point it anywhere A hosted API, your own cloud tenancy, or a server on the plant network — vLLM, Ollama, llama.cpp and their equivalents all expose the same contract.
PORTABILITY · 04 Or nothing at all Leave it unset and the AI surfaces switch off. Import, validation, scoring, the punch list, export and sync are unaffected.

Which matters more than it first appears. The model is a dependency you choose, not one you inherit — a customer who will not send tag data outside their network can run it on their own hardware and change nothing else, and a model that is superseded next year is a configuration line rather than a rebuild.

Deterministic where it can be: naming, completeness scoring, unit conversion, the standards audit and the punch list are all plain code. Anything the application decides on its own is attributed — as a rule, as the model, or as a rule the model reviewed — so "the AI did it" is answerable rather than a shrug.

Part five

Attribution, reversal and concurrency

The part a reviewer will want to see for themselves — and the part that makes the rest of this document checkable rather than claimed.

Audit One trail, no side channel Human and model writes land in the same log, with the actor, the moment, and what changed — field by field, old value to new. There is no path that writes without recording.
Reversal A run, not a row Each agent run and each import is revertible as a unit: every field it overwrote goes back to what it held before. The revert is itself audited, so undoing is as accountable as doing.
Retention Before/after values age out; the fact does not Old change-sets are cleared on a schedule while the audit entry — who did what, and when — is kept. Reversibility has a window; accountability does not.
Concurrency Optimistic, with a real token Edits carry the row's version. Two engineers on one tag produce a conflict a person resolves, rather than a last-write-wins silently discarding somebody's work.
Workflow Transitions are validated Draft, pending, in review, approved, with cancelled as the exit. Illegal moves are refused by the server, so the lifecycle is a rule rather than a convention.
Identity Roles, hashed credentials, scoped tokens Editing and administration are separate rights, and read-only accounts genuinely cannot write — including through the agent.
Part six

Delivery and viewers

Out to the systems that operate the plant — and the drawings, read where the register is rather than in another application.

Targets Per record, with the reply kept A configured endpoint with its own auth. One delivery per tag, and the receiving system's accept-or-refuse response is stored against that record — which is what lets the agent repair exactly what was refused, using that system's own reason.
Triggers Manual, on approval, or scheduled Sync now, push as tags are approved, or a cron expression on a background runner. None of them is on by default.
Files CSV, Excel, JSON, PDF One projection behind all four, so the exports cannot disagree about what a column means. The PDF is a document rather than a dump — the columns a person scans, its own row count declared, headings repeated per page.
2D The sheet as an index DXF, SVG and DEXPI parsed in the browser, every tag on the sheet indexed and clickable, and the tag you opened framed automatically.
3D Tag-aware geometry IFC and glTF, plus an optimized form that keeps every object's name and bounding box at roughly a sixth of the size — the difference between a model that opens on site and one that does not. Pick a solid, get its tag.
Both at once Locked to one tag Drawing and model side by side, following each other. When you pick something the sheet does not draw — steel, a support — it says so rather than appearing broken.
Part seven

The evidence behind it

Every claim above is checkable, and most of them are checked on every build. This is what a reviewer can run for themselves.

Unit & integration935xUnit, against a real database
Browser120Playwright, over the running app
Standards checks15each with a catalogued defect proving it still fires
Demorecorded livereal model calls, real database, numbers measured not written
Surface parity A new column reaches every surface, or says why not Every descriptor on a tag is wired to the filter grammar, the agent's reader and the export — or names the reason it is not. A build walks all of them and fails listing any surface a new column has not reached, so the register cannot quietly grow a field that only half the application knows about.
Cross-language parity Rules duplicated in JS are pinned to the C# original Where a rule has to exist on both sides of the wire, a test reads the real source of both and fails when they diverge — rather than a copy of the rule agreeing with itself.
Planted defects Every check has something to find The demo register carries a catalogued set of deliberate faults, so a check that quietly stops reporting fails the build instead of looking like a clean register.
The recording is a test A skipped beat fails the run The demo asserts its own scene list and its own starting data before it films, so the recording proves the feature rather than merely showing it — and a beat that cannot be filmed stops the run instead of quietly shortening it.

What this adds up to: a working system with real engineering underneath it. The checks run, the tests hold, and the demo is recorded live against a real register — the numbers in it are measured on the way past, not written afterwards. The roadmap is tracked in the open alongside the code, so what comes next is a plan rather than a discovery.