Put a runtime control and visibility layer between your app and external AI providers.
CLARIXO Core Runtime API is the LLM-side runtime layer for teams that need routing, fallback, guard behavior, runtime memory, explainable execution, and runtime visibility between their product and the model providers they already use. It is built for experienced teams that want to inspect how AI decisions happen in production, integrate deliberately, and move into deeper LLM-side control with clarity.
Keep your provider choices. Add runtime control on top.
Provider routing and fallback control
Choose runtime paths more deliberately, degrade more clearly, and avoid blind provider switching.
Guard behavior and boundary control
Apply policy and safety boundaries without turning your product into an opaque black box.
Runtime memory and context continuity
Carry forward the context that matters to execution decisions without relying on brittle app-side glue.
Explainable execution review
Inspect why a route, fallback, guard branch, or degraded outcome happened in a more operational form.
Use this page to understand the runtime contract and the correct next implementation step.
Read the runtime contract first
Use this page to understand the role of routing, fallback, guard behavior, runtime memory, and explainable execution before integration work begins.
Read plan and access truth as part of the integration proof
CLARIXO already resolves capability and access truth through runtime contract handling. Capability-facing responses can expose requested capability, plan code, billing status, allowed capabilities, authorization state, and deny reason so integration teams can verify what the current project is actually allowed to do.
Use Integration Preview for live project state
Open Integration Preview when you need to inspect current runtime state, active project context, and the next correct step for that project.
Use docs and manual pages for setup details
Move into docs, the Integration Manual, and the contract reference when you need implementation order, field semantics, verification flow, rollout guidance, and capability-layer reading order.
Built for teams that already have AI in production or near production.
Product teams shipping AI features
Especially when the current stack works, but the operational boundary around it is still too thin.
Teams needing auditability
Useful when you need more structured runtime evidence for why a response path or degradation happened.
Teams that do not want to replace providers
CLARIXO fits teams that want a runtime layer above providers rather than another foundation model pitch.
What should be true before you treat the integration as real
- A live project state exists, not only a request record
- The minimum request path works with CLARIXO actually in the loop
- Core runtime signals such as status, plan, access state, and observability can be read
- Capability-proof fields such as requested capability, plan code, billing status, authorization result, allowed capabilities, and deny reason can be interpreted correctly
- The next technical reading path is clear across docs, manual, and contract reference
- Paid continuity is understood before broader production usage
Choose the next page deliberately
- Use Integration Preview for live project state and next-step reading
- Use Docs for the documentation stack and capability ladder
- Use Integration Manual for setup order, verification flow, and governance rollout
- Use Contract Reference for exact field-level semantics
- Use Pricing when the project is ready for ongoing plan continuity
Teams this page is built for
- Teams already shipping AI features or close to production
- Teams that need runtime visibility without replacing providers
- Teams that need auditable routing, fallback, and guard behavior
- Teams that want implementation clarity before broader rollout
- Teams that need a runtime layer rather than another model endpoint
Read the runtime contract here, then start the Core Runtime path that matches your need.
Need user-facing evidence without changing your runtime path first?
Need grouped review after evidence export?
Questions a first API visitor will usually have
Is this page the live integration surface?
No. This page is the contract-facing entry. Use Integration Preview when you need to inspect live project state and the next correct step for that project.
Do I need to replace my current model provider?
No. CLARIXO is designed as a runtime layer that sits between your app and external AI providers.
How should I get started?
Read the runtime contract here first, then move into Integration Preview, docs, or the Integration Manual depending on whether you need live project review or technical setup guidance.
Where should I go if I want the technical setup details?
Use Docs, the Integration Manual, and the Contract Reference after entering through this API page.
What counts as a successful first integration?
A successful first integration means more than sending one request: an active project state is visible, the minimum request path works with CLARIXO actually in the loop, and core runtime signals such as status, plan, access state, and observability can be read. It should also be possible to interpret capability-proof fields such as requested capability, plan code, billing status, authorization result, allowed capabilities, and deny reason when the current project or request does not qualify for a higher capability path.
What happens after the implementation fit is validated?
Continue through pricing so the project can move forward into paid usage without restarting the integration from zero. Then use Docs and the Integration Manual when your next step stays inside Core Runtime API, use Evidence API when your team needs separate evidence export for behavior records, or use Audit Workspace when you need grouped case review, reviewer context, and structured review export unlocked through Responsibility.