CLARIXO
Four Entry Paths for AI Governance Infrastructure

Start from the LLM-side, the User-side, Continuity Governance, or CLARIXO OriginOS.

CLARIXO is structured across four entry paths. Use the LLM-side when you need runtime control and governed execution, the User-side when you need behavior evidence and formal review, Continuity Governance when you need continuation visibility across long-running AI workflows, and CLARIXO OriginOS when you want governed system generation inside origin-core-architecture.

LLM-side runtime governance
User-side evidence governance
Continuity governance visibility
OriginOS governed system generation
Self-binding governance
CLARIXO is also bound by the same rules it introduces, rather than standing above them.
runtime.boundary_logic=self_applied
evidence.traceability=enabled
approval.exception_layer=none
reviewable=true · traceable=true · constraint_bound=true
Law Enforcement API For investigative, regulated-response, and official review systems that need read-only responsibility signals without execution control.
Choose the path that matches your current work, then expand across the other sides when your system needs deeper control, stronger evidence, or a dedicated build environment.
LLM-side

Control model-side execution in production.

LLM-side Protection Start here when your first need is model-side runtime protection, governed execution, and production control before silent runtime drift.
Start LLM-side Protection Learn More
Core Runtime API, AgentOps, and Approval Gateway details are available after entering the LLM-side path.
Continuity Governance

Continuity Governance includes the Continuation Foundation and HIC Runtime.

Continuation Foundation: preserves continuation visibility, lineage, restoration semantics, transfer constraints, and downstream continuity awareness without taking over execution authority.
HIC Runtime: extends continuity into runtime human-interaction governance for hesitation-aware guidance, overload-aware pacing, pause-safe continuation, and one-step interaction support.
HIC builds on the Continuation Foundation rather than replacing it. Both belong under the same Continuity Governance path.
Open Continuity Governance Learn More
Continuation Foundation and HIC Runtime API entries are grouped inside the Continuity Governance path, not exposed as separate homepage entry buttons.
CLARIXO OriginOS

Generate governed systems inside origin-core-architecture.

CLARIXO OriginOS is the governed system-generation source layer for turning human intent into ACE-admissible, responsibility-bound, verified, evidence-backed implementation work inside CLARIXO.
Open CLARIXO OriginOS Learn More
OriginOS replaces the former OC Platform display path and keeps system generation bounded to origin-core-architecture.
User-side

Start with evidence and review before disputes escalate.

User-side Protection Start here when your first need is user-facing behavior evidence, responsibility review, and a clean path toward formal audit surfaces.
Start User-side Protection Learn More
Free Evidence Intake, L2 Object Interface, and Audit Workspace details are available after entering the User-side path.
See architecture
Runtime snapshot
OUTPUT PATH
intent → router → model selection → guard review → final output path
GUARD INFLUENCE
signal=policy-watch → evaluation=bounded → action=reviewable-pass → control=visible
CONTROL SIGNALS
fallback=standby · drift=low · confidence=90% · review_state=clear
Local Integration Quickstart

Connect from your own local environment and view a real Native API response.

This is the fastest way to verify that your local bridge is working, your request is reaching the API, and the returned result can be viewed locally. The first successful result is expected to be a dry-run response, not a live automatic file write.
1. Create your local files Create a local folder and add local_bridge.py and preview.html.
2. Run the bridge Run python local_bridge.py to create a local last_response.json from a real API call.
3. Start local preview Run python -m http.server 8000 and open http://127.0.0.1:8000/preview.html.
Minimum request example
{
  "task": "Generate a local implementation suggestion",
  "target_file": "app/example.py",
  "goal": "Show a real API response in local preview",
  "source_code": "print('hello world')"
}
Open Full Local Integration Guide View Field Requirements and Error Guide

What success looks like

Terminal output shows DONE
A local last_response.json is created
The browser preview shows real JSON
The first accepted response is a structured dry-run package

Common first error

If the API returns missing_source_code, add source_code to the payload and run the bridge again.

What this first result means

Your local bridge is connected, the request is reaching the Native API, and the system can already return a structured package. The first correct result is visible and reviewable before any live apply behavior is introduced.

Why It Matters

Most AI systems become risky in the runtime path before teams can explain what changed

The problem is usually not the model alone. It is the hidden runtime path around the model: routing drift, silent fallback, weakened confidence, unexpected guard intervention, and execution behavior that stays invisible until it becomes product, trust, cost, or operational risk.
ROUTING

See how execution was actually routed

Trace which path, model, or provider handled the request so runtime behavior can be inspected instead of assumed from the final answer alone.

FALLBACK

Catch silent path changes earlier

See when execution shifted to a different model, provider, or fallback route before hidden behavior changes become quality, cost, or reliability problems.

CONFIDENCE

Understand when decision quality weakened

Track where signals became weaker, less stable, or harder to trust so teams can investigate fragile outputs before they become production incidents.

GUARD + CONTROL

Review intervention before it becomes surprise behavior

Inspect when guard logic constrained, rerouted, paused, or escalated execution so teams can review how control behavior influenced the final output path.

Capability Direction

CLARIXO gives teams a standard path from visibility to review to governed execution

CLARIXO is not just another observability dashboard. It begins with runtime visibility, moves into operator-facing review when live cases need handling, and reaches governed execution when approval, block, escalation, or boundary re-checks become part of production reality.
Runtime Visibility Inspect routing, fallback, confidence, guard behavior, and execution signals before hidden runtime behavior becomes production risk.
→
Operator Review Move uncertain runtime cases into operational handling, next-action review, and operator workflows.
→
Governed Execution Apply explicit approval, block, escalation, and commit-boundary control before execution handoff continues.
Builder · establish runtime visibility first
Pro · deepen integration and live runtime usage
Business · add operator review when runtime cases need handling
Responsibility · move retained evidence into formal review when responsibility becomes real
Enterprise · apply formal control when execution boundaries become operational
Next Step

Choose the next path deliberately

Start with the path that matches your current work. Choose the LLM-side when you need runtime control, the User-side when you need evidence and review, Continuity Governance when you need continuation visibility, or CLARIXO OriginOS when you want governed system generation inside CLARIXO.

Each homepage path opens into a separate entry surface first. API details, Protocol and Manual pages, workspace surfaces, evidence intake, L2 object flows, and advanced operational tools are intentionally kept inside their corresponding path pages or Docs.