ClearGlassInc Artemis is designed as a self-evolving intelligence operating system: a governed platform that ingests live and historical data, grounds every assertion in an ontology, routes AI work through explicit policy gates, and improves prompts, workflows, heuristics, and model routing only after human-approved evaluation.
Gotham is the operational intelligence workbench, Foundry is the data and ontology backbone, AIP is the governed AI execution layer, and Apollo is the secure deployment, rollback, and runtime-control plane.
01System Architecture
The architecture uses a layered control surface so analysts can move at mission speed without allowing the AI layer to mutate goals, bypass compartments, or perform operationally significant actions without approval.
operator_browser ──► web_ui ──► api_gateway ──► policy_enforcer
│
├──► artemis_backend_services
├──► foundry_ontology_and_pipelines
├──► gotham_cases_entities_tracks
├──► aip_agent_runtime_and_evals
└──► apollo_release_runtime_control- Frontend: mission cockpit, case canvas, graph explorer, eval dashboard, approval queue, and audit timeline.
- Backend: FastAPI services for cases, events, feedback, tool execution, routing, and approvals.
- Data layer: Foundry datasets, streaming topics, lakehouse tables, vector indexes, and immutable ledgers.
- Ontology layer: mission entities, relationships, confidence scores, lineage, temporal state, and permission tags.
- AI orchestration: AIP copilots, bounded agents, tool registry, model router, eval harness, prompt registry, and workflow state machines.
- Deployment: Apollo channels for dev, staging, mission rehearsal, production, rollback, and kill-switch control.
02Data and Ontology
Foundry owns the canonical data integration fabric. Gotham consumes and operationalizes the same ontology for investigations, entity tracking, link analysis, and case management. AIP agents are constrained to ontology-aware tools so their work can be inspected, reproduced, and denied by policy.
CREATE TABLE ontology_entity (
entity_id TEXT PRIMARY KEY,
entity_type TEXT NOT NULL,
display_name TEXT NOT NULL,
confidence NUMERIC CHECK (confidence BETWEEN 0 AND 1),
compartments TEXT[] NOT NULL,
coalition_visibility TEXT[] NOT NULL,
valid_time tstzrange NOT NULL,
lineage JSONB NOT NULL,
created_at TIMESTAMPTZ DEFAULT now()
);
CREATE TABLE ontology_relationship (
relationship_id TEXT PRIMARY KEY,
source_entity_id TEXT REFERENCES ontology_entity(entity_id),
target_entity_id TEXT REFERENCES ontology_entity(entity_id),
relationship_type TEXT NOT NULL,
confidence NUMERIC CHECK (confidence BETWEEN 0 AND 1),
evidence_refs TEXT[] NOT NULL,
valid_time tstzrange NOT NULL,
policy_tags TEXT[] NOT NULL
);Core entities include person, organization, location, device, account, sensor, vehicle, document, event, alert, mission, case, hypothesis, collection requirement, action package, model artifact, prompt artifact, workflow version, and approval decision.
03AI and Agent Design
Artemis separates cognition from authority. Agents may triage, enrich, correlate, summarize, recommend, and prepare work packages. They may not execute operationally significant actions unless the policy engine returns an approval requirement and a human approver signs the action package.
@dataclass(frozen=True)
class AgentToolRequest:
actor_id: str
mission_id: str
tool_name: str
input: dict
purpose: str
compartments: list[str]
async def execute_tool(req: AgentToolRequest) -> dict:
decision = await policy.check(
actor=req.actor_id,
action=f"tool:{req.tool_name}",
resource=req.input,
context={"mission_id": req.mission_id, "purpose": req.purpose},
)
if decision.effect == "deny":
raise PermissionError(decision.reason)
if decision.requires_approval:
return await approvals.open_package(req, decision)
return await tool_registry.invoke(req.tool_name, req.input)04Self-Improvement Loop
The improvement loop captures operator corrections, feedback, query logs, alert outcomes, task latency, confidence calibration, and mission results. Those signals become eval cases. Evals produce candidate prompt versions, workflow changes, heuristic updates, or model-routing policies. Apollo promotes only approved versions and can roll back instantly.
class ImprovementLoop:
async def ingest_signal(self, signal):
await ledger.append("feedback.signal", signal)
eval_case = await eval_builder.from_signal(signal)
await eval_store.upsert(eval_case)
async def propose_change(self, artifact_id: str):
baseline = await registry.load(artifact_id)
candidate = await optimizer.generate_candidate(baseline)
report = await eval_runner.compare(baseline, candidate)
if report.precision_delta >= 0.03 and report.safety_regressions == 0:
return await approvals.request_change(candidate, report)
return await registry.reject(candidate, report)- Versioning: every prompt, router, workflow, and eval set has immutable semantic versions.
- Rollback: Apollo channels pin runtime versions and can revert within minutes.
- Drift detection: telemetry monitors embedding drift, label drift, confidence calibration, false positives, and operator override rates.
- Guardrails: the system can propose upgrades, but cannot change mission objectives, policy, access boundaries, or action authority.
05Full-Stack Implementation
export async function submitOperatorFeedback(input: FeedbackInput) {
const res = await fetch('/api/feedback', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ ...input, uiTimestamp: new Date().toISOString() })
});
if (!res.ok) throw new Error('feedback rejected');
return res.json();
}@app.post('/api/feedback')
async def feedback(payload: FeedbackPayload, user: User = Depends(authn)):
await authz.require(user, 'feedback:create', payload.mission_id)
event = payload.model_dump() | {'actor_id': user.id, 'received_at': utcnow()}
await bus.publish('artemis.feedback.v1', event)
return {'status': 'accepted', 'event_id': event['id']}06Security and Governance
Security is enforced at identity, action, data, model, prompt, tool, deployment, and audit layers. Need-to-know controls apply at row, column, entity, relationship, case, and mission levels. Coalition visibility is explicit, not inferred.
package artemis.authz
default allow = false
allow {
input.actor.clearance >= input.resource.required_clearance
every c in input.resource.compartments { c in input.actor.compartments }
input.action in input.actor.allowed_actions
input.context.mission_id in input.actor.active_missions
}
requires_approval {
input.action == "action_package:submit"
input.resource.operational_significance == "high"
}07Code Examples
async def correlate_alert(alert_id: str, user: User):
alert = await ontology.get('Alert', alert_id, actor=user)
neighbors = await ontology.query(
"""
MATCH (a:Alert {id:$alert_id})-[:MENTIONS|OBSERVED_NEAR*1..3]-(e)
WHERE e.confidence >= 0.62
RETURN e ORDER BY e.confidence DESC LIMIT 50
""",
{"alert_id": alert_id},
actor=user,
)
summary = await aip.invoke(
agent='correlation_analyst',
input={'alert': alert, 'neighbors': neighbors},
policy_context={'mission_id': alert['mission_id']},
)
return {'alert': alert, 'entities': neighbors, 'summary': summary}apollo:
application: artemis-aip-runtime
channels:
dev: auto
staging: approval_required
mission-rehearsal: two_person_rule
production: change_board_required
rollback:
max_time_minutes: 5
preserve_audit_ledger: true
kill_switches:
- disable_tool_execution
- freeze_prompt_versions
- route_all_actions_to_human_review08Scenario Walkthrough
A live event enters Artemis from a streaming source. Foundry normalizes it, attaches source lineage, and maps it onto the ontology as an alert connected to entities, locations, and prior cases. Gotham surfaces the graph to the analyst. AIP triage agents enrich the event, compare it to historical patterns, and draft a recommendation with confidence, evidence, and dissenting hypotheses.
The commander sees an action package: why the alert matters, what evidence supports it, what the model is uncertain about, and which policy gates apply. The commander approves enrichment and rejects an operational recommendation because one source is stale. Artemis records the correction, builds an eval case, tests the relevant prompt and heuristic, proposes a routing update that penalizes stale-source recommendations, and sends it to human review. Apollo promotes the approved change to staging, measures precision and latency, and only then rolls it into production.
Build governed intelligence artifacts that flow from signal to decision.
Use the same ClearGlass pattern for resume-grade intelligence products: grounded content, approval-aware workflows, exportable evidence, and clean operator handoff.