Integrate
Add an independent trust layer to any AI system you already run.
No retraining your model. No exposing its weights. No rewrite of your inference loop beyond a few lines. This page is the complete path from "nothing installed" to "a fault gets caught and healed automatically", everything below is real, working code, not a diagram of an idea.
1. Install
pip install AuxAI-sdkPython 3.9+. No GPU required to run the trust layer itself.
2. Configure once
Thresholds live in one YAML file, not scattered across your codebase.
# AuxAI.config.yaml, one file, thresholds tuned to your model's
# real score distribution, not shipped as placeholders.
tier0:
fingerprint_source: fleet # never "self"
check_every_n_frames: 1
meta:
canary_interval_seconds: 5
checks: [canary, output_sanity, jitter, fleet_consistency]
tier1:
drift_test: page_hinkley
sustained_window: 30 # inferences, not a single spike
ood_threshold: auto # calibrated against a held-out split
remedy:
fine_tune_on_confirmed_drift: true
validate_before_hot_reload: true
max_rollback_versions: 5
escalate_after_repeat_faults: 3 # then stop retrying, alert a human
3. Call it from your inference loop
from AuxAI import TrustLayer
trust = TrustLayer.from_config("AuxAI.config.yaml")
output = my_model.predict(input_batch)
result = trust.evaluate(
model_output={ # whatever your model already computes
"embedding": output.embedding,
"confidence": output.confidence,
"prediction": output.prediction,
},
sensor_reading=telemetry.snapshot(), # optional, any extra context you have
)
if not result.trusted:
actuator.hold() # veto the action before it happens
log.warn(result.decision, result.trust_score)
4. What you get back
A diagnosis, not just a number.
Every call returns which tier flagged the problem and what it recommends, so your system can react differently to "the monitor itself is compromised" versus "the model is seeing something new", the two require completely different responses.
TrustDecision(
trusted=False,
reliability_score=0.11, # 0.0 - 1.0, T x H combined
diagnosis="tier0_hash_mismatch", # which tier flagged it
recommended_action="quarantine_and_resync",
tier_results={
"tier0": "fault",
"meta": "ok",
"tier1": "ok",
"integrity": "not_evaluated",
},
)Not on Python, or the model runs elsewhere?
Run it as a sidecar. Any language reaches it the same way.
A C++ perception stack, a Rust control loop, a Go microservice, all of them can call the same three-field evaluate() contract over a local REST or gRPC endpoint, with the trust layer running as its own lightweight container next to the model it's watching.
# docker-compose.yml, run the trust layer as a sidecar next to
# any model-serving container, regardless of what it's written in.
services:
my-model:
image: your-org/your-model:latest
AuxAI-sidecar:
image: AuxAI/sidecar:latest
volumes:
- ./AuxAI.config.yaml:/etc/AuxAI/config.yaml
ports:
- "8500:8500" # local REST/gRPC endpoint for the evaluate() call
Full endpoint reference
The same sidecar also exposes a complete HTTP API, not just the one call.
| Method & path | Purpose |
|---|---|
| GET /health | Liveness check |
| POST /v1/monitor/frame | Submit a raw model output for the trust layer to evaluate |
| POST /v1/monitor/report | Submit an already-computed result from an external pipeline, recorded as-is |
| GET /v1/monitor/status | Latest status for one unit |
| GET /v1/monitor/history | Recent frame history for one unit |
| GET/PUT /v1/config | Read or update runtime thresholds live, no restart required |
| POST /v1/fl/submit-update | Submit a client update for federated aggregation |
| GET /v1/fl/global-model | Fetch the current fleet-verified global model state |
Before a real deployment, not just a demo
A short checklist, the same one we run internally.
- Decide the integration path: in-process, a remote client, or raw HTTP against the sidecar.
- If your model's embedding dimension or class count is unusual, plan for an eventual fine-tuning pass on your own labeled data, the adapters get a new system working immediately, not optimally calibrated for free.
- Recalibrate the behavioral self-test's canary bounds against your own trained model before relying on it for a real decision, shipped defaults are placeholders, not tuned to your distribution.
- Decide explicitly whether this deployment controls the watched model's checkpoint, leave write access off for any model that genuinely isn't yours to modify.
- Confirm whether network discovery is appropriate for your environment, LAN-visible by default, with an explicit opt-out for a security-sensitive deployment.
- If the trust layer's decision gates a physical action, verify that your specific control stack actually enforces the veto, don't assume it does without checking, see the case studies page for a documented example of exactly this gap.
FAQ
What people ask before their first integration.
Does this require access to my model weights?
No. The SDK is black-box by design, it reads outputs only (embedding, confidence, prediction). This is deliberate: it means the trust layer works even for models you can't or won't expose internals of, and it can't itself become a vector for extracting your model.
What if my model doesn't output an embedding?
Most models already compute one internally (the penultimate layer, or a pooled feature map) even if it is not normally exposed, exposing it is usually a one-line change. If truly unavailable, Tier 0 and Meta still run fully; only Tier 1 drift detection needs it.
Can it run fully offline, with no fleet connection?
Yes. Detection, diagnosis, and local remedy (fine-tune, validate, rollback) all run in-process with no network dependency. Only the fleet-wide trust anchor and cross-unit learning need connectivity, and those degrade gracefully, buffering and syncing when a connection returns.
What language is the SDK written in?
Python natively today. Any other language reaches it over a small local REST/gRPC call to the same evaluate() logic running as a sidecar, shown above, the wire format is three JSON fields in, one decision object out.
What's the actual performance cost?
The trust layer itself is roughly 154x smaller in parameter count than a typical perception model it might audit, and Tier 0/Meta/Tier 1 run in-process, in the same inference loop, adding a single forward pass through a much smaller network.
Stuck on an integration, or running something unusual?
AuxAI was built to be model- and language-agnostic from day one. If your setup doesn't fit the patterns above, that's a conversation, not a dead end.