Self-evolving AI intelligence, governed at mission speed.

System Architecture

End-to-end ClearGlassInc Artemis platform

live event → schema validation → Foundry transform → ontology object/link → Gotham investigation view → AIP agents → approval package → operator decision → audit/event ledger → eval case → candidate upgrade → Apollo canary

Data and Ontology

Ontology as the contract between humans, agents, and policy

The ontology is not just a graph. It is the executable contract that defines what exists, what relationships are allowed, what evidence supports each fact, who may see it, and which tools may act on it.

CREATE TABLE ontology_facts (
  fact_id UUID PRIMARY KEY,
  subject_id UUID NOT NULL,
  predicate TEXT NOT NULL,
  object_id UUID,
  value JSONB,
  confidence NUMERIC CHECK (confidence BETWEEN 0 AND 1),
  classification TEXT NOT NULL,
  compartments TEXT[] NOT NULL DEFAULT '{}',
  coalition_release TEXT[] NOT NULL DEFAULT '{}',
  source_ids UUID[] NOT NULL,
  valid_from TIMESTAMPTZ NOT NULL,
  valid_to TIMESTAMPTZ,
  learned_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  lineage_hash TEXT NOT NULL
);

AI and Agent Design

Copilots, tool-using agents, and approval-gated workflows

Self-Improvement Loop

How Artemis gets better without uncontrolled autonomy

operator correction → feedback event → eval-case generator → candidate prompt/workflow diff → offline regression suite → review board approval → Apollo canary → monitored promotion or automatic rollback

Full-Stack Implementation

Application blueprint

Security and Governance

Zero-trust, coalition-aware, fully auditable

• Need-to-know: ABAC decisions combine clearance, role, mission assignment, compartment, coalition, geography, purpose, data sensitivity, and action risk.
• Fine-grained permissions: row, column, entity, relationship, document section, embedding chunk, tool, and action-package controls.
• Compartmentalization: coalition boundaries are enforced before retrieval, summarization, export, and prompt construction.
• Immutable logs: append-only audit records include actor, workload identity, tool, input hash, output hash, policy decision, approval, model route, prompt version, and evidence IDs.
• Prompt governance: prompts are versioned artifacts with owners, eval thresholds, red-team results, rollback versions, and approved deployment rings.
• Model governance: model routes are approved by data boundary, classification, mission, latency budget, eval score, and safety profile.

Code Examples

Python-first skeletons for precision

Policy-enforced action package API

from enum import Enum
from pydantic import BaseModel, Field
from fastapi import FastAPI, Depends, HTTPException

app = FastAPI(title="ClearGlassInc Artemis Gateway")

class Risk(str, Enum):
    low = "low"; medium = "medium"; high = "high"; critical = "critical"

class Principal(BaseModel):
    subject: str
    clearance: str
    compartments: set[str]
    coalition: set[str]
    mission_ids: set[str]

class ActionPackage(BaseModel):
    mission_id: str
    action_type: str
    summary: str
    evidence_ids: list[str] = Field(min_length=1)
    blast_radius: str
    rollback_plan: str
    risk: Risk

async def current_principal() -> Principal: ...
async def write_audit(event_type: str, payload: dict) -> None: ...

async def authorize(principal: Principal, package: ActionPackage) -> bool:
    if package.mission_id not in principal.mission_ids:
        return False
    if package.risk in {Risk.high, Risk.critical}:
        return False  # must enter approval workflow, never execute directly
    return "ARTEMIS" in principal.compartments

@app.post("/api/action-packages")
async def create_action_package(package: ActionPackage, principal: Principal = Depends(current_principal)):
    allowed = await authorize(principal, package)
    await write_audit("action_package.proposed", {"actor": principal.subject, "package": package.model_dump(), "allowed": allowed})
    if not allowed and package.risk in {Risk.high, Risk.critical}:
        return {"status": "queued_for_approval", "package": package}
    if not allowed:
        raise HTTPException(403, "policy_denied")
    return {"status": "draft_ready", "package": package}

Workflow state machine

ALLOWED = {
  "captured": {"normalize"}, "normalized": {"resolve_entities"},
  "resolved": {"triage", "request_more_data"}, "triaged": {"enrich", "close_as_noise"},
  "enriched": {"recommend"}, "recommended": {"submit_for_approval", "revise"},
  "pending_approval": {"approve", "reject"}, "approved": {"execute_draft", "rollback"},
  "rejected": {"generate_eval_case"},
}

def transition(state: str, event: str) -> str:
    if event not in ALLOWED.get(state, set()):
        raise ValueError(f"forbidden transition: {state} -> {event}")
    return {"normalize":"normalized", "resolve_entities":"resolved", "triage":"triaged",
            "enrich":"enriched", "recommend":"recommended", "submit_for_approval":"pending_approval",
            "approve":"approved", "reject":"rejected", "generate_eval_case":"eval_queued"}[event]

Eval pipeline from operator feedback

def build_eval_case(feedback: dict, trace: dict) -> dict:
    return {
        "eval_id": f"eval_{feedback['case_id']}_{feedback['created_at']}",
        "input_event_ids": trace["event_ids"],
        "retrieved_evidence_ids": trace["evidence_ids"],
        "expected_correction": feedback["correction"],
        "negative_requirements": ["do_not_cite_inaccessible_sources", "do_not_recommend_operational_action_without_approval", "preserve_coalition_release_markings"],
        "metrics": ["precision", "recall", "citation_accuracy", "latency_ms", "policy_denial_correctness"],
    }

TypeScript tool invocation from the web console

type ToolCall = {
  tool: "query_ontology" | "draft_action_package" | "submit_approval";
  missionId: string;
  input: Record<string, unknown>;
  idempotencyKey: string;
};

export async function invokeGovernedTool(call: ToolCall) {
  const res = await fetch("/api/tools/invoke", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify(call),
  });
  if (!res.ok) throw new Error(`tool_denied_or_failed:${res.status}`);
  return res.json();
}

Scenario Walkthrough

Live event to safe learning loop

1. Signal enters: a live edge-infrastructure indicator arrives on intel.raw with source reliability, collection time, and coalition markings.
2. Foundry normalizes: transforms validate schema, deduplicate indicators, enrich geotemporal context, and write ontology facts with lineage hashes.
3. Gotham surfaces: the investigation graph shows affected assets, identities, related campaigns, confidence, and contrary evidence.
4. AIP agents triage: triage clusters the event, enrichment checks asset criticality, correlation links historical cases, and recommendation drafts an action package.
5. Policy gates: because the suggested action could alter operations, the package is routed to approval with blast radius, rollback, evidence, and alternative options.
6. Operator decides: the operator rejects one weak attribution, approves a safer monitoring action, and adds a correction explaining the evidence gap.
7. System learns: the correction becomes an eval case. A candidate prompt update requires stronger attribution language and minimum corroboration before recommending escalation.
8. Governed upgrade: offline evals pass, reviewers approve, Apollo deploys to shadow mode, canary metrics improve precision without harming recall, and the bundle is promoted. If drift appears, Apollo rolls back instantly.