Documentation across the LLM-side, the User-side, and the Development Platform.
CLARIXO documentation is organized around three first-entry sides. Use LLM-side documentation for Core Runtime control and governed execution, User-side documentation for evidence export and later formal review, and Development Platform documentation for local integration, dry-run structure, and implementation-side guidance.
Start with the fastest local path before you go deeper into the full docs stack
If your team wants to verify the Native API from its own local environment first, start here. This path shows how to run a small local bridge, send a real request, write the returned JSON into a local file, and inspect the result in a local browser preview.
This first local test is designed to prove that your local bridge is working, the API is reachable, and the returned result can be viewed inside your own environment before any broader rollout work begins.
local_bridge.py and preview.html in one local folder.python local_bridge.py to create last_response.json from a real API request.python -m http.server 8000 and open http://127.0.0.1:8000/preview.html.What success looks like
The first correct result should show a real accepted response, a local last_response.json, and a structured dry-run package visible in the local browser preview.
Most common first error
If the API returns missing_source_code, add source_code to the payload and run the local bridge again.
What this first stage means
The first successful local request proves local connectivity and structured package return. It does not yet mean that live local file apply behavior is active.
CLARIXO is a runtime control and visibility layer, not a raw passthrough model endpoint
Applications send user intent and approved context into CLARIXO. CLARIXO then owns routing, guard decisions, execution strategy, fallback handling, runtime memory, and structured explainable execution. The goal is runtime control, visibility, and stable behavior rather than direct dependence on a single model vendor.
Runtime chooses the execution path
Intent resolution, execution mode, and fallback transitions stay inside the runtime layer.
Boundary and policy stay attributable
Guard outcomes, escalation conditions, and runtime control constraints remain explicit and reviewable.
Decisions remain auditable
Execution path, provider behavior, degraded states, and observability fields can be surfaced without turning the host into the runtime owner.
CLARIXO documentation now starts from three first-entry sides
Use the documentation stack according to the side your team is entering first. LLM-side documentation covers Core Runtime control, routing, fallback, guard behavior, and later governed execution. User-side documentation covers evidence export first, then later grouped review and formal handoff. Development Platform documentation covers local integration, dry-run response reading, field requirements, and implementation-side workflow.
Core Runtime and governed execution path
Start here when your team is evaluating CLARIXO as the runtime layer between applications and external AI providers. Use Integration Preview, Core Runtime API, Integration Manual, and later capability guidance to establish the execution boundary and rollout path.
Open LLM-side StartEvidence export first, formal review later
Start here when your team needs user-facing behavior export without moving runtime control first. Use Evidence API Start and Evidence API first. Move into Audit Workspace later when the next need becomes grouped review, reviewer context, and formal handoff.
Open User-side StartLocal integration and implementation-side path
Start here when your team needs local bridge testing, dry-run response reading, field-level requirements, and implementation-side guidance for the OC Platform Native API local path.
Open Development Platform StartUse the documentation stack according to the capability path you are entering next
CLARIXO documentation does not only separate manuals by function. It also maps to the product path and capability your team is entering next: start with Core Runtime API when runtime control comes first, move into Evidence API when evidence export is the immediate requirement, move into Audit Workspace when grouped review, reviewer context, and case export become necessary, and treat deeper governance layers such as AgentOps, Approval Gateway, and organization-wide control as later capability steps inside Core Runtime API. This capability ladder applies to Core Runtime API, while Evidence API and Audit Workspace remain separate documentation paths for evidence export and grouped review.
Runtime control and visibility foundation
Use Docs, API, Integration Manual, and Integration Preview to establish the runtime boundary, verify the execution chain, and confirm that routing, fallback, guard behavior, runtime memory, and explainable execution are visible before broader rollout.
AgentOps reading and operator review layer
Move into Observation, queue-detail, runtime-detail, and AgentOps-style reading surfaces when live operator review, queue interpretation, and decision-path reading become operational requirements.
Approval Gateway and execution governance layer
Move into Approval Gateway and execution governance guidance only when approve, block, escalate, or governed execution behavior becomes part of the real production control path.
Organization-wide governance and deployment design
Treat Enterprise as the organization layer: policy layering, ownership design, audit depth, rollout structure, and multi-team deployment control beyond the first integration and first review loop.
Run a small local bridge, write the returned JSON locally, and inspect the result in your own browser
This is the shortest first working path for teams that want to verify the Native API from their own local environment before going deeper into the broader documentation stack.
local_bridge.py and preview.html.python local_bridge.py to call the real Native API and create a local last_response.json.python -m http.server 8000 and open http://127.0.0.1:8000/preview.html to inspect the returned JSON in your own browser.Send the minimum required fields first, then read the first-stage errors directly from the local response file
The minimum first working request should include the target file path and the current source code. When the request fails, inspect last_response.json first and fix the missing field before retrying.
{
"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')"
}
target_file and source_code should be present in the first working local request.missing_source_code, add source_code to the payload and run the local bridge again.last_response.json was replaced. Rerun the local bridge, inspect the file directly, and refresh the browser with Ctrl + F5.Contract rules are interpreted as normative requirements
The CLARIXO contract reference uses uppercase requirement words to separate mandatory compatibility rules from strong recommendations and optional extensions.
Use the manuals for workflow, the references for exact fields, and the support pages for implementation examples
Reading path for runtime control and visibility work
Use this page to understand how CLARIXO documentation is organized and which manual to read next.
Correct setup, verification flow, and first-pass readiness
Use the integration manual for boundary setup, implementation order, evidence-first verification, common integration mistakes, and the practical rollout path that turns a basic integration into a production-grade runtime control and visibility layer.
Turn a working chain into a trustworthy production baseline
Use the calibration manual to align scene semantics, operator review logic, degraded interpretation, and readiness before scale-up.
Learn how to read overview, queue-detail, breakdown, and runtime-detail signals
Use the observation manual to interpret health, fallback, low-confidence, review, provider, breakdown, and queue-detail signals correctly.
Start from symptoms and trace back to the right layer
Use the troubleshooting manual when telemetry is blank, attribution is wrong, degraded output is flattened, or runtime signals do not match reality.
Use optimization guidance safely and correctly
Use the Optimization Assistant manual to understand diagnosis, recommendation packets, preview selection, and safe apply boundaries.
Exact request / response / context field semantics
Use the contract reference for stable field names, required meanings, and normalized contract expectations.
Copy-paste-ready implementation patterns
Use the integration skeletons for minimal working request, response, degraded, observability, and structured failure examples.
The CLARIXO manual stack now separates setup, calibration, observation, troubleshooting, and optimization usage
Use Core Runtime API when your team is entering runtime control first. Use Evidence API when your team needs evidence export without moving runtime control first. Use Audit Workspace when your team needs grouped review, reviewer context, and case export built on evidence records.
For Core Runtime API technical setup, follow Integration Manual → Calibration Manual → Observation Manual. Use Integration Preview to create or inspect a live project and review how runtime behavior appears before broader rollout.
Inside Core Runtime API, Builder and Pro stay focused on runtime control and visibility, Business adds AgentOps reading and review workflows, Control adds Approval Gateway and execution governance, Responsibility extends into Audit Workspace, and Enterprise extends into organization-wide governance, policy layering, and deployment design.
High-impact capability: Approval Gateway and execution governance can affect live output behavior. See Integration Manual for Operator State Execution Governance and rollout guidance.
Keep Troubleshooting Manual and Optimization Assistant Manual for later-stage operations. Supporting references include Contract Reference and Integration Skeletons.
Recommended reading flow:
1. Docs
2. Integration Manual
3. Integration Preview
4. Calibration Manual
5. Observation Manual
6. Troubleshooting Manual
7. Optimization Assistant Manual
Capability ladder:
8. Builder / Pro = runtime control and visibility foundation
Recommended reading flow:
1. Docs
2. Integration Manual
3. Integration Preview
4. Calibration Manual
5. Observation Manual
6. Troubleshooting Manual
7. Optimization Assistant Manual
Capability ladder:
8. Builder / Pro = runtime control and visibility foundation
9. Business = AgentOps reading and operator review
10. Control = Approval Gateway and execution governance
11. Responsibility = Audit Workspace and responsibility-sensitive review
12. Enterprise = organization-wide governance and deployment design
Public readiness set before broader launch:
12. Live project state visible
13. Minimum request path verified
14. Core runtime signals readable
15. Pricing continuation path confirmed
16. Support boundary understood
Supporting documents used across the full manual stack:
17. Contract Reference
18. Integration Skeletons
19. Compatibility Policy
20. Host implementation
21. Pre-launch verify
Executive summary:
22. Capability Overview + Industrialization Assessment