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 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.