Intelligence that learns under command.
A secure, coalition-aware full-stack design that fuses live and historical data, reasons through bounded agents, and proposes measurable upgrades without manufacturing its own authority.
Seven planes. One governed decision path.
The architecture isolates presentation, intelligence, execution, policy and audit concerns so a partial failure cannot silently become an unauthorized state.
Experience plane
React/TypeScript analyst workspace, commander cockpit, case graph, timeline, geospatial layers, provenance drawer and an approval inbox. Optimistic UI is prohibited for consequential actions.
API & orchestration
Python FastAPI gateway, typed mission APIs, Temporal-style durable workflows and idempotent event handlers. Every call carries actor, tenant, compartment, purpose and correlation context.
Data & Ontology
Foundry pipelines normalize streams into versioned datasets; the Ontology exposes governed objects, links, actions and functions as the shared operational contract.
Intelligence plane
AIP copilots and agents retrieve only policy-filtered evidence. A deterministic router selects models by classification, latency, quality and cost bounds.
Policy & audit
Default-deny ABAC/ReBAC decisions sit beside protected actions. Append-only audit events record input hashes, evidence, model/prompt versions, tool calls and approvals.
Runtime & delivery
Apollo promotes signed, evaluated releases across disconnected or cloud environments with canaries, health gates, immutable identity and last-known-good rollback.
Ontology as the operational contract.
Objects are temporal, lineage-bearing and permission-scoped. Agents receive the same constrained object view as the operator, preventing retrieval from becoming an authorization bypass.
| Object / link | Core properties | Operational behavior |
|---|---|---|
Entity | entity_id, type, aliases, confidence, valid_time, system_time | Person, organization, asset, location or digital identity with merge/split lineage. |
Observation | source_id, payload_hash, observed_at, classification, reliability | Immutable evidence; corrections create superseding records rather than erasure. |
Assessment | claim, confidence, rationale, evidence_refs, analyst | Separates evidence from interpretation and preserves dissenting assessments. |
MissionContext | objective, ROE profile, coalition, compartments, time window | Scopes retrieval, tools, model route, latency budget and approval authority. |
Case / Alert | state, severity, owner, SLA, disposition, outcome | Drives human queues and generates labeled evaluation examples. |
ActionPackage | proposal, evidence, risk, reversibility, approval_state | State machine: draft → reviewed → approved/rejected → executed → verified. |
RELATES_TO | valid_from/to, confidence, provenance, hypothesis_id | Temporal graph edge; asserted, inferred and disputed links remain distinguishable. |
Ingest contract
- Schema registry rejects ambiguous, oversized or duplicate events.
- Watermarks and idempotency keys support replay.
- Raw evidence remains immutable; normalized views are reproducible.
- Every transformation emits dataset, code and source lineage.
Permission contract
- Tenant + coalition + compartment + purpose-of-use checks.
- Row, column, object, link and action-level controls.
- Field redaction occurs before search indexing and model context.
- Derived objects inherit the strictest contributing classification.
Bounded agents, typed tools, explicit authority.
Models propose; deterministic services authorize. Every tool is schema-bound, allowlisted, time-limited and independently audited.
Analyst copilot
Builds provenance-linked timelines, compares hypotheses, identifies evidence gaps and drafts intelligence products. It abstains when source coverage or confidence is below mission thresholds.
Commander copilot
Surfaces decision points, risk, alternatives and confidence without hiding dissent. It can prepare—but never self-approve—an action package.
Specialist swarm
Triage, enrichment, graph correlation, geospatial, summarization and red-team agents exchange typed artifacts, not free-form authority. A governor enforces budgets and terminal states.
Gets better through evidence—not autonomy.
Operator corrections and outcomes become governed evaluation material. The platform may propose changes to prompts, routing, heuristics or workflows; only an authorized release owner can promote them.
Promotion gates
Required: no policy regression, provenance coverage at target, precision/recall non-inferiority, bounded p95 latency/cost, adversarial suite pass, two-person approval for high-risk routes, signed release and rollback pointer.
Drift & trust
Monitor input distribution, label shift, calibration, citation validity, override/rejection rate, operator trust, latency and mission outcome proxies. Threshold breach freezes promotion and returns traffic to the last-known-good version.
Full-stack implementation blueprint.
Each tier has a narrow responsibility, an observable SLO and a fail-closed degradation mode.
Web UI
React + TypeScript, graph/map/timeline canvases, WebSocket subscriptions, accessible command palette, evidence-first answer cards and mandatory confirmation ceremonies.
Gateway
FastAPI + Pydantic contracts, workload identity, request budgets, idempotency, rate limits and a policy decision point. SSE/WebSockets provide bounded live updates.
Services
Ingest, identity resolution, case, alert, action package, feedback, evaluation, model registry and audit services. Durable workflows isolate retries from business decisions.
Streaming & storage
Kafka-compatible partitioned event log; Foundry datasets/lakehouse for canonical history; transactional store for workflow state; object storage for encrypted evidence.
Retrieval & inference
Permission-aware lexical/vector/graph retrieval with source snapshots. Model router selects only approved endpoints and enforces context, output and latency budgets.
Operations
OpenTelemetry traces, structured privacy-aware logs, eval dashboards, queue depth and policy-denial alerts. Apollo manages progressive delivery, attestation and rollback.
Zero trust from source to action.
Classification, coalition boundary and purpose-of-use policy follow data through ingestion, retrieval, generation, export and audit.
Identity & need-to-know
Phishing-resistant MFA, short-lived workload identities, continuous device posture and default-deny ABAC/ReBAC. Break-glass access is time-bound, witnessed and reviewed.
Model & prompt governance
Immutable registry versions, signed evaluation evidence, approved data-use scopes, prompt-injection isolation and output validation. Models cannot alter policy or tool grants.
Audit & recovery
Hash-chained append-only decisions, independently queryable audit plane, correlation IDs, key rotation and tested restoration. Denied actions produce no partial operational side effect.
Python-first control boundaries.
Representative skeletons show the critical invariants. Palantir SDK calls are intentionally represented behind typed ports until the target environment and generated Ontology SDK are verified.
class ActionState(StrEnum):
DRAFT = "draft"; REVIEWED = "reviewed"; APPROVED = "approved"
EXECUTED = "executed"; VERIFIED = "verified"
ALLOWED = {DRAFT: {REVIEWED}, REVIEWED: {APPROVED}, APPROVED: {EXECUTED}, EXECUTED: {VERIFIED}}
async def transition(package, target, actor, policy, audit):
if target not in ALLOWED.get(package.state, set()):
raise InvalidTransition(package.state, target)
decision = await policy.authorize(actor=actor, action=f"package:{target}", resource=package)
if not decision.allowed:
await audit.append("action.denied", package.id, actor.id, decision.reason)
raise PermissionDenied()
if target is ActionState.APPROVED and not package.has_distinct_human_approver:
raise HumanApprovalRequired()
return await package.advance_atomically(target, decision.id)@dataclass(frozen=True)
class EvalGate:
min_precision: float = .92
min_recall: float = .86
min_provenance: float = .98
max_p95_ms: int = 1800
def promotion_decision(candidate: Metrics, baseline: Metrics, gate: EvalGate) -> Decision:
checks = {
"policy_regressions": candidate.policy_regressions == 0,
"quality": candidate.precision >= gate.min_precision and candidate.recall >= gate.min_recall,
"provenance": candidate.provenance_coverage >= gate.min_provenance,
"latency": candidate.p95_ms <= gate.max_p95_ms,
"non_inferior": candidate.mission_score >= baseline.mission_score,
}
return Decision(proposable=all(checks.values()), checks=checks, auto_promote=False)async def evidence_for_case(case_id: UUID, principal: Principal) -> list[Evidence]:
scope = await policy.read_scope(principal, object_type="Observation", purpose="mission-analysis")
if scope.is_empty: raise PermissionDenied()
rows = await ontology.observations.search(
case_id=case_id, compartments=scope.compartments, valid_at=clock.now(), limit=200
)
return [Evidence.from_object(row).redact(scope.fields) for row in rows]03:17 UTC — a weak signal becomes a governed decision.
A technically credible path from event to outcome demonstrates where machines accelerate work and where human authority remains absolute.