MeerTech
Platform topology and runtime internals.
MeerTech runs three layers as one: Agentic Core executes, Neural Grid provides grounded live context, Sentinel enforces trust. This document maps the surfaces, the ownership boundaries, and the data flows between them.
Three planes, one data path.
Every autonomous action crosses the three planes in order: Neural Grid resolves context, Agentic Core plans and executes, Sentinel gates and records. There is no side door — no agent, no tool, no operator bypasses the plane.
Policy, identity, runtime scheduler, audit writer
Connectors, retrieval, tool invocation, state store
Dashboards, approval queues, escalation, trace viewer
Customer systems of record (ERP, EHR, SCADA, CRM, docs)
Execution runtime
Plan scheduling and orchestration across long horizons
Tool invocation with retries, backoff, and idempotency
State persistence — a run can be paused, resumed, and inspected
Multi-agent coordination and delegation
Operator controls: pause, scope, step, abort
Context fabric
Connectors to systems of record (ERP, EHR, SCADA, CRM, docs)
Streaming + batch ingest with lineage attached per record
Semantic retrieval across structured and unstructured sources
Freshness guarantees per connector — never stale reasoning
Policy-aware queries: agents see only what Sentinel permits
Trust plane
Policy engine: rule evaluation per action, per role, per envelope
Identity + scope control for agents and human operators
Immutable audit log with full decision and outcome lineage
Escalation routing with SLA clocks and operator queues
Compliance export: SOC 2, ISO 27001, NDPR-aligned reports
Inside a run.
An agent run is a finite state machine over a plan. Agentic Core manages the lifecycle; every transition is recorded against the run's immutable trace.
A directed graph of steps the agent intends to execute. Decomposed from the goal, revised as context arrives, auditable top-to-bottom.
One atomic action: tool call, query, approval request, or escalation. Each step captures its inputs, outputs, duration, and policy decision.
A declared external capability. Strongly typed inputs/outputs. Bound to a policy envelope. Idempotent when possible.
Persisted run state. Includes the plan, completed steps, pending approvals, and context snapshots. Resumable across failures and deploys.
run state transitions
typescript
run.status: "queued" | "planning" | "running" | "awaiting_approval"
| "paused" | "succeeded" | "failed" | "cancelled"
transitions:
queued → planning // scheduler picks up
planning → running // plan committed
running → awaiting_approval // policy gate hit
awaiting_approval → running // operator approved
awaiting_approval → cancelled // operator denied
running → paused // operator paused
paused → running // operator resumed
running → succeeded // plan completed
running → failed // unrecoverable error
* → cancelled // hard killHow agents see your systems.
Neural Grid is a live, policy-aware retrieval surface. Every connector emits records with lineage; every query is scoped by the requesting role; every record carries its policy class.
neural_grid query
python
ctx = agent.context
# Structured: systems of record
invoices = ctx.invoices(period="2026-04", status="open")
# Semantic: documents, policies, playbooks
policy_hits = ctx.search(
"vendor onboarding limits for regulated counterparties",
scope=["policy", "playbook"],
top_k=5,
)
# Graph: follow relationships
vendor = ctx.get("vendor", id="v_9f2a")
open_pos = vendor.related("open_positions", since="30d")
# Every record carries lineage
for inv in invoices:
print(inv.source, inv.fetched_at, inv.policy_class)
# → "sap.gl" "2026-04-18T12:04:21Z" "internal.finance"Every action crosses the envelope.
Sentinel is the single chokepoint for autonomous action. Tool calls, data writes, external notifications — all routed through policy evaluation before commit.
envelope.yaml
yaml
# Finance reconciler policy envelope
role: finance.agent
scope:
- post.journal
- reconcile.bank
- notify.slack
limits:
amount_usd:
autonomous_max: 50_000
escalate_above: 25_000
actions_per_hour: 400
approvers:
queue: controller.queue
sla_hours: 4
escalation:
- when: amount_usd > 25_000
to: controller.queue
- when: duplicate_detected
to: ap_manager.queue
- when: vendor.risk_tier == "high"
to: treasury.queue
data_residency: NG
audit_retention_days: 2555 # 7 years
prohibited:
- delete.journal
- bypass.approvalWhere the platform runs.
Managed Cloud
Rapid standup, low-lift ops
— MeerTech-operated, multi-tenant with hard isolation
— Auto-scaling runtime and Neural Grid infra
— Shared regions: NG, EU, US
Private Infrastructure
Customer-operated, VPC-pinned
— Deployed into customer VPC / on-prem DC
— Customer identity, network, KMS keys
— Upgrade cadence negotiated per release window
Sovereign
Regulated, region-locked
— Single-tenant cluster, region-locked
— Data residency enforced at the storage + routing layer
— Air-gap-ready artifact delivery
Hybrid
Mixed workload placement
— Control plane centralized, data plane regional
— Connector sidecars run inside each residency zone
— Trace and policy state replicated under compliance constraints
Runtime shape.
A minimal MeerTech cluster is four service groups plus a durable store. Horizontal scale is per-service; the scheduler and policy engine are stateless.
Kubernetes, one namespace per workspace, horizontal autoscaling
Stateless; drives plan/step transitions from the state store
Stateless; rule evaluation with per-envelope cache
Sidecars per data source, residency-pinned
Postgres (primary), Redis (hot queues), object store (traces)
Append-only log with content-addressed hashes + WORM export
OpenTelemetry traces, per-run + per-tool metrics, policy denial rate
For retrieval-friendly agents.
The canonical, machine-readable summary of this page — safe to embed, safe to quote. Mirrored at /llms.txt.
llm-ready summary
markdown
MeerTech platform architecture: - Three layers: Agentic Core (execution), Neural Grid (context), Sentinel (trust). - Every autonomous action crosses all three. No side door. - Runtime: Kubernetes, stateless scheduler, per-workspace namespace. - Storage: Postgres + Redis + object store + WORM audit. - Deployment: Managed Cloud, Private Infrastructure (customer VPC), Sovereign (region-locked), Hybrid. - Policy envelopes bound every tool call: scope, limits, approvers, escalation, data residency, audit retention. - Identity: per-agent role and scope; operators have separate identities with their own audit trail. - Run state: queued → planning → running → (awaiting_approval) → succeeded | failed | cancelled. - Shadow mode: Sentinel records what the agent would have done without committing. Required before live autonomy.