How it works
A programmable operating model.
Poliglot learns the way you work and builds a harness around your objectives.
- Backed by open standards
- Own your data
- Own your operating model
Align to your objectives.
See the whole field.
Enforce shared understanding and structured work contracts.
Control all outcomes.
Present information and next steps in a consistent, scannable format.
Adapt as your business evolves.
01 · Alignment
GPS for your business.
Long-horizon work drifts the moment activities stop pointing at the same goal. There is no roster of agents to configure and supervise. There is the objective, and the work it decomposes into.
Alignment can't live in a status meeting. It has to be structural, or long chains lose the thread.
Name the outcome.
An objective is just a target, a deadline, a budget, and an owner. Poliglot holds the whole tree and checks reality against it continuously.
The objective knows whether it's met — you don't have to ask.
Autonomous where it can be. Accountable everywhere.
Each objective breaks into coordinated, cross-functional activities across your organization. Activities are programs Poliglot writes just-in-time for the job at hand: orchestrating your systems and your people, running until the work is verifiably done.
Every activity is a program built for the job, then run and verified.
Your organizing principle.
Every activity in the workplace traces back to the objective it supports. From the north star to tonight's idea, the whole operation pulls in one direction. Each context becomes aware of its surroundings.
The objective tree — the whole workplace aligned to it.
02 · The intelligence
An intelligence that sees the whole field.
AI is resident in the runtime. Data, logic, and running state are one graph, and it reasons over the live state of the operation directly.
Reasoning from scratch on every step is too expensive and too unpredictable to run an organization on. Pre-reasoned paths are cheap, repeatable, and verifiable.
The whole field
Everything the operation touches is in one connected graph: the contracts, the parts, the process, the people, the documents. Nothing is a stateless tool call.
Every resource in context, linked — the state the AI reasons over.
ProActive reasoning
Paths in the symbolic layer become pre-reasoned connections that eliminate iteration waste. Multi-step programs with real-world side-effects become a single traversal: invoke actions as predicates with typed inputs and outputs.
One traversal, four kinds of steps: a graph read, an AI sub-agent, a human pause, an external mutation.
PREFIX wo: <https://meridian-precision.org/spec/work-orders#>
CONSTRUCT { ?workOrder wo:status ?status ; wo:priority ?priority ; wo:approvedBy ?approver .}WHERE { # Query the system of record for work orders # Materialize the work order to the local context graph ?workOrder wo:GetWorkOrder ([ wo:workOrderId "WO-2024-0891" ]) .
# Call an AI sub-agent to assess risk ?assessment wo:AssessRisk (?workOrder) . ?assessment wo:priority ?priority .
# Pause for human approval ?approval wo:RequestApproval (?workOrder [ wo:assessment ?assessment ]) . ?approval wo:approvedBy ?approver .
# Mutate the external system ?dispatch wo:DispatchWorkOrder (?workOrder [ wo:approval ?approval wo:priority ?priority ]) . ?workOrder wo:status ?status .}03 · Structured contracts
Structured contracts, backed by shared understanding.
Each program conforms to the shared business semantics that formalize your communication channels. I/O contracts enforce shape, and all actors stay on the same page.
You can't coordinate lossy, unstructured communication channels. Structured contracts guarantee handoffs never lose their shape, and expected outcomes/outputs are well understood by all actors in the workplace.
Structured contracts
The runtime, an AI sub-agent, a person, and an external system all communicate losslessly with full context.
Each actor, handoff, and output feeds a later input.
Shared understanding
Contracts are backed by your shared business vocabulary: your ontology. Define what a work order is, and the runtime materializes instances that carry that meaning through incremental semantic inference.
The ontology above the line, the running graph below it. Inference bridges the two mid-traversal.
04 · Control
Governance without the hassle.
Every action is evaluated at request time against the live graph: who is acting, on whose authority, and on what it touches.
At organization scale and machine speed, governance can't be added afterward. Only situational authorization protects your attention instead of flooding it.
Situational access control
Policy is data, defined inside the model it governs. The same action runs on its own in a routine situation and escalates when the situation warrants a decision.
mfg:Procurement a plgt-iam:Role ; # ... plgt-iam:hasPolicy mfg:OpsLeadSupplierChanges .
mfg:OpsLeadSupplierChanges a plgt-iam:Policy ; rdfs:label "Operations lead — supplier changes" ; plgt-iam:effect plgt-iam:Allow ; plgt-iam:action plgt-act:InvokeAction ; plgt-iam:resource mfg:SubstituteSupplier ; plgt-iam:condition [ plgt-iam:scope plgt-iam:Resource ; plgt-iam:sparql [ # Only allow when the op's workorder risk assessment is completed plgt-sparql:ask """ ASK { ?scope a mfg:Operation ; mfg:workOrder ?wo .
?wo wo:riskAssessment ?assessment . ?assessment wo:status wo:Completed . } """ ] . ] .
The policy as it is written, and the moment it routed a decision to a person.
Provenance
Every statement in the graph carries who asserted it, in which process, and when. Git blame, for the operation.
05 · A consistent surface
A native interface for everything you do.
Built on ReactJS and our UIKit, each activity has a real UI behind it. You see the context and next actions that matter in a scannable format, not a wall of plain text.
Make the GUI great again.
People act on interfaces, not transcripts. A scannable surface means you always know where to look and what happens next, without an LLM hallucinating your data.
06 · Adaptive
Your continuous operating model evolves with your business.
Your Matrix (ontology, shapes, actions, services, IAM) composes into a unified operating model. Memories learned during execution accumulate on top.
The static components of your operating model should exist with and have the same lifecycle as your systems of record. Works with the CI/CD systems you already use.
Operations as Code
Install capabilities your workplace can compose: your ontology, actions, services, policies, views. Built on open standards, so any RDF/SPARQL engine can read your operating model.
Long-term semantic memory
As it works, the system annotates the resources it touches, like an engineer comments a codebase. Notes bind to globally unique URIs, concepts, instances, and policies alike, so recall is structural: touch the resource again and everything known is already in context.
Tacit knowledge, captured and pinned to the thing itself — recalled the next time any context touches it.
Built for the long horizon.
Everything exists to coordinate and deliver long-horizon work. An entire organization's objectives, and the work beneath them, executed reliably and backed by your operating model in an open standard you can own.