How it works
ACI is organized into production components that work together end-to-end. The product is intentionally described at a system level so you can understand what you deploy, operate, and govern - without exposing proprietary implementation detail.
01
Update Plane
Ingests events, proposes micro-updates, orchestrates evaluation and rollout workflows.
02
Protected Set Gate
Runs regression suites that must not regress beyond tolerances. Prevents “learning” that breaks critical behavior.
03
Ledger + Capsules
Provides traceability and a scope boundary for rollback and unlearning operations.
04
Memory Layer
Stores long-tail evidence and update context under explicit budgets.
05
Consolidation Manager
Controls growth and schedules heavier maintenance work off the critical path.
06
Uncertainty + Calibration
Produces confidence signals, calibration reports, and coverage analytics for routing and policy decisions.
07
Observability Dashboard
Shows the seven-metric scorecard, change history, and alerting.
08
SDK + Edge Agents
Integration libraries and edge runtimes for buffering, offline operation, and fleet sync.
Benchmarks that reflect production reality
ACI is evaluated as a system, not just a model. We report not only quality, but also forgetting, editability (anchor drift), uncertainty, compute, and memory - the factors that decide whether continual
updates are shippable.
Frank-7: the seven metrics we report
Frank-7 is a seven-metric scorecard for continual adaptation. It is designed to prevent “benchmarks that look good but ship badly” by requiring stability and cost metrics alongside accuracy.
Plasticity
How quickly ACI improves after drift or new data.
Stability (forgetting)
How much previously working behavior regresses.
Editability
Collateral change after rollback/unlearning (measured as anchor-set drift A0)
Uncertainty
Confidence as a decision signal (calibration and risk coverage).
Accuracy / Quality
Task success, segmented by domain/modality.
Memory
Peak memory footprint for updates and runtime constraints.
Compute
Update/eval runtime and (optionally) serving overhead.
Benchmarks - Streaming text
Benchmark theme: continuous document ingestion and rapidly changing vocabulary (enterprise assistant proxy).updates are shippable.
Results: quality, stability, editability, uncertainty
Method
Accuracy (final)
Forgetting (avg)
Editability (A0 drift)
Uncertainty (final)
textoni (ACI)
0.8787 ± 0.0291
0.0225 ± 0.0167
0.02329 ± 0.00183
1.3751 ± 0.1853
textrls (ACI)
0.8538 ± 0.0328
0.0287 ± 0.0126
0.03814 ± 0.00289
1.2809 ± 0.1661
textkrls_ald (ACI)
0.6925 ± 0.0261
0.0650 ± 0.0211
1.28e-10 ± 0.0
1.3863 ± 0.1926
texteaci (E-ACI)
0.2600 ± 0.0247
0.2100 ± 0.0196
0.2051 ± 0.3896
0.0095 ± 0.0001
textsgd (baseline)
0.2700 ± 0.0283
0.2000 ± 0.0218
0.00337 ± 0.00659
0.0124 ± 0.0006
Results: compute and memory (budget signals)
Method
Compute (seconds)
Peak RSS (MB)
textoni (ACI)
19.15 ± 4.90
631 ± 123
textrls (ACI)
22.11 ± 5.43
544 ± 105
textkrls_ald (ACI)
19.19 ± 3.50
631 ± 85
texteaci (E-ACI)
24.92 ± 10.17
931 ± 219
textsgd (baseline)
10.53 ± 2.08
431 ± 65
Interpretation
In this benchmark configuration, select ACI operating points show high final accuracy and lower forgetting than a simple SGD baseline.
Editability is operating-point dependent; anchor drift (A0) quantifies collateral change under unlearning/rollback protocols.
Choose operating points based on the 7 scorecard, not accuracy alone.
Visual: accuracy vs update compute
Visual: forgetting vs editability (anchor drift)
Assuming these patterns scale to LLM systems
If similar stability and rollback properties extend to LLM deployments, ACI can materially reduce the number of heavyweight fine-tune cycles required to keep assistants current. Even when serving overhead is temporarily higher, the lifecycle cost can fall because you shift most adaptation events from “big retrain” to “small micro-update” - with explicit governance.
“ACI is disruptive not because it learns online, but because it makes learning shippable: tested, budgeted, and reversible.”
Benchmarks - Perception drift proxy (DomainNet incremental)
Benchmark theme: domain incremental perception drift (multimodal / perception proxy). Includes a caution on baselineharness parity.
Important benchmark note
Baseline accuracies in this setup appear anomalously low. Verify harness parity and evaluation settings before using headline accuracy comparisons across domains.
Use this benchmark primarily for stability/editability signals and cost profiling under budgets.
Results: quality, stability, editability, uncertainty
Method
Accuracy (final)
Forgetting (avg)
Editability (A0 drift)
Uncertainty (final)
krls_epoch (ACI)
0.1610 ± 0.0036
0.0005 ± 0.0006
6.48e-05 ± 1.62e-06
5.8431
rls (ACI)
0.2641 ± 0.0066
0.0078 ± 0.0010
6.48e-05 ± 1.62e-06
5.8431
krls_ald (ACI)
0.0825 ± 0.0024
0.0005 ± 0.0004
0.0000
5.8431
eaci (E-ACI)
0.1975 ± 0.0063
0.0625 ± 0.0048
5.71e-05 ± 1.54e-06
5.8431
sgd (baseline)
0.0040 ± 0.0018
0.0009 ± 0.0006
0.0410 ± 0.0021
5.6990 ± 0.0171
Results: compute and memory (budget signals)
Method
Compute (seconds)
Peak RSS (MB)
krls_epoch (ACI)
12.69 ± 1.17
1565 ± 33
rls (ACI)
15.38 ± 1.32
1351 ± 42
krls_ald (ACI)
39.67 ± 1.41
4480 ± 62
eaci (E-ACI)
219.01 ± 5.10
1424 ± 29
sgd (baseline)
5.30 ± 0.61
1036 ± 49
Interpretation
Stability and editability signals can be strong for select ACI operating points in this setup.
Compute and memory vary widely by operating point. Budget-aware selection is essential.
Do not over-index on a single metric; use the full Frank-7 contract.
Visual: accuracy vs update compute (log x-axis)
Keep models current without burning the planet (or moving compute to orbit).
ACI makes continual adaptation a low-energy operation by shifting most “freshness work” fromheavyweight fine-tunes to lightweight micro-updates with governance.
Why this is disruptive
It changes the economics of “freshness”: more updates, less retraining.
It makes safer continual learning feasible for fleets (robots, edge devices, smartphones) where heavy retraining is impractical.
It reduces the need for extreme infrastructure proposals whose goal is to subsidize constant retraining energy and thermal constraints.
It creates a new category: budgeted continual intelligence - where stability and reversibility are first-class product requirements.
Suggested sustainability statement
ACI is designed to reduce lifecycle energy by replacing many retraining events with micro-updates and by making rollback/unlearning operational. We publish compute and memory metrics alongside quality because sustainable AI requires predictable budgets, not just higher accuracy.
One continual intelligence layer. Many deployment realities.
Whether you serve an enterprise assistant, operate a robot fleet, or ship an on-device model, ACI provides the same contract: budgeted micro-updates, protected sets, rollback, and unlearning.
Solution cards
LLMs and Enterprise Assistants
Keep assistants current, safe, and policy-aligned with micro-updates and
regression gates.
Multimodal and Document AI
Recover from template and modality drift with segmented evaluation and uncertainty-aware routing.
Robotics and Autonomous
Systems Adapt safely with fleet canaries, safety rings, and rollback when conditions shift.
Edge and Mobile (On-device)
Support on-device inference with offline-safe agents and budgeted update paths.
Personal and Embedded Assistants
Maintain personalization and preferences without constant retraining, with scoped unlearning for privacy.
Keep LLMs current without constant fine-tuning.
ACI helps LLM applications adapt to new knowledge, new tools, new policies, and evolving customer needs - while preventing regressions through protected sets and rollback.
LLM use cases
How ACI fits in an LLM stack
- ACI typically runs as a sidecar micro-update service or as a CI/CD gate that produces vetted update artifacts for your serving layer.
- Protected sets should include: policy adherence tests, tone/style checks, tool-use correctness, refusal behavior, and high-risk edge cases.
- Segment evaluation by tenant, domain, and interaction type to avoid averaging away regressions.
"We moved from monthly fine-tunes to governed micro-updates. Our assistant stayed current, regressions dropped, and rollbacks became routine instead of catastrophic."
Drift happens. Recover fast - and prove you did.
ACI helps multimodal and document AI systems adapt when inputs change: new templates, new sensors, new styles, and new domains - while keeping protected behaviors stable and measurable.
Document AI and multimodal use cases
Document AI and multimodal use cases
Segment evaluation
by modality/template/domain so regressions are visible (not averaged away).
Uncertainty
outputs to route low-confidence cases to human review or alternative pipelines.
Protected sets
to lock down critical extraction fields, safety constraints, and compliance requirements.
Roll back quickly
when new templates or sensors introduce unexpected failure modes.
Benchmark context
The DomainNet incremental benchmark is used as a proxy for perception drift, with explicit disclosure when baselines appear anomalous and require harness validation.
Robots that adapt - without drifting into unsafe behavior.
ACI supports edge-first and cloud-assisted adaptation workflows for fleets, with safety rings,
canary promotion, and rollback.
Robotics use cases
Deployment patterns
Edge-first + fleet promotion
Robots buffer events locally, propose updates when slack time exists, and
promote validated updates through fleet canaries.
Cloud-assisted adaptation
Compute-heavy evaluation occurs off-robot; vetted artifacts are shipped to devices.
Hybrid safety ring
Separate conservative safety modules from more plastic task modules, so safety remains stable while task performance adapts.
Why rollback matters for fleets
In fleets, regressions are expensive: downtime, safety incidents, and operational chaos. ACI makes rollback routine by maintaining change provenance and supporting staged rollout.
Continual intelligence on devices that cannot afford retraining.
ACI supports on-device inference and update workflows for edge devices, smartphones, and embedded systems - bringing protected sets, rollback, and unlearning to the device layer.
Where this matters
On-device inference and update model
How ACI fits in an LLM stack
- Inference runs on device under strict latency budgets.
- Events are buffered locally when offline and synced when connectivity allows.
- Updates can be evaluated opportunistically (e.g., when the device is charging or idle) and then promoted through a fleet manager.
- Protected sets and rollback ensure that new behaviors do not destabilize critical device functions.
Energy story for devices
Micro-updates are designed to be lightweight. The same lifecycle logic that reduces datacenter energy (e.g., 5120x lower energy per adaptation event in an illustrative comparison) also reduces the need to push heavy retraining workloads onto device fleets.
Undo is a feature, not a crisis response.
ACI provides rollback to last known good behavior and scoped unlearning requests to remove influence of specific data. Both are governed operations with verification hooks.
Unlearning scenarios
Privacy deletion requests
Remove influence of user data or tenant data when required by policy or regulation.
Document revocation
Unlearn documents that were incorrect, outdated, or should no longer be used.
Policy reversals
Undo a behavior update that caused regressions or unintended side effects.
Data poisoning response
Rapidly remove influence of malicious or corrupted data streams.
Rollback vs unlearning
Rollback
Revert to a previous known-good state (typically an earlier artifact). Fast, operational, and low-risk.
Scoped unlearning
Remove influence of a defined scope (documents, records, tenant data) with verification and collateral drift limits.
What you can measure
For every rollback/unlearning action, ACI encourages publishing
affected scope
protected-set pass/fail
anchor drift (A0)
changes to the seven-metric scorecard
Industries and sub-verticals
Financial services
Banking, insurance, fintech
Use cases: repeatable behavior with bounded failure modes
Healthcare & life sciences
Providers, payers, pharma
Use cases: clinical documentation, patient support, compliance-safe assistants, imaging workflows.
Government & public sector
Citizen services, defense, regulators
Use cases: policy assistants, multilingual support, auditability, data retention and deletion.
Retail & eCommerce
Search, recommendations, visual assistants
Use cases: new SKU adaptation, multimodal grounding, customer support.
Manufacturing & logistics
Factories, warehouses, supply chain
Use cases: robotics adaptation, inspection drift recovery, anomaly detection.
Telecom & networking
Network ops, customer support
Use cases: tool-using agents, incident copilots, dynamic knowledge.
Energy & utilities
Grid ops, asset maintenance
Use cases: predictive maintenance drift, multimodal inspection, field support.
Automotive & mobility
Fleet and autonomy
Use cases: perception drift, safe rollout, rollback for regressions.
Media & marketplaces
Moderation and trust
Use cases: evolving adversaries, policy updates, uncertainty routing.
Cybersecurity
Detection and response
Use cases: evolving threats, tool orchestration, regression gates on critical detections.
Legal & professional services
Case support, research
Use cases: policy compliance, controlled updates, audit trails.
Education
Tutoring and content
Use cases: freshness without regressions, personalization with unlearning controls.
Regulated enterprise AI (finance, healthcare, government)
Regulated industries need proof and control: what changed, why it changed, how it was tested, and how to undo it. ACI is designed for this reality: protected sets define non-negotiable behavior; rollouts are staged; rollback/unlearning are auditable operations.
- Protected sets for policy and compliance workflows (PII handling, safe refusals, domain rules).
- Audit-ready change history and exportable evidence of gating results.
- Scoped unlearning for deletion requests and tenant boundaries.
- Budgeted operation for predictable infra and SLOs.
Retail multimodal assistants and search
Retail changes daily: new SKUs, new imagery, new promotions, and new policy constraints. ACI supports rapid adaptation while preventing regressions on critical customer experience metrics through protected sets and segmented evaluation.
Suggested KPI list
- Grounding correctness (image + text)
- Policy compliance (restricted items, age gates)
- Search relevance and zero-result rate
- Return/refund policy adherence
- Latency and budget metrics
Robotics fleets and autonomy
Fleets require safe promotion. ACI supports edge-first buffering, fleet canaries, and rollback to last known good behaviors when field conditions change.
Copilot freshness without regressions
Adapt to new internal docs quickly while protected sets ensure policyand safety behavior do not regress.
Customer support policy updates
Ship rule changes (refunds, eligibility, tone) as micro-updates with canary rollout and rollback.
Tool-using agent upgrades
Improve tool selection and action policies while protecting high-risk workflows and refusal behavior.
Document extraction under template drift
Maintain field accuracy as vendors change layouts; segment by template and use uncertainty routing.
Document extraction under template drift
Maintain field accuracy as vendors change layouts; segment by template and use uncertainty routing.
Perception drift recovery
Handle lighting/sensor shifts with budgeted updates and fleet-safe promotion.
On-device personalization
Learn preferences locally while supporting scoped unlearning for privacy deletion and “forget me” requests.
Robotics safety ring
Keep conservative safety constraints stable while allowing plasticity in task policies.
Fraud and anomaly detection
Adapt to new attack patterns while protecting critical detections and false-positive limits.
Copilot freshness without regressions
Adapt to new internal docs quickly while protected sets ensure policy and safety behavior do not regress.
Customer support policy updates
Ship rule changes (refunds, eligibility, tone) as micro-updates with canary rollout and rollback.
Tool-using agent upgrades
Improve tool selection and action policies while protecting high-risk workflows and refusal behavior.
Document extraction under template drift
Maintain field accuracy as vendors change layouts; segment by template and use uncertainty routing.
Perception drift recovery
Handle lighting/sensor shifts with budgeted updates and fleet-safe promotion.
On-device personalization
Learn preferences locally while supporting scoped unlearning for privacy deletion and “forget me” requests.
Robotics safety ring
Keep conservative safety constraints stable while allowing plasticity in task policies.
Fraud and anomaly detection
Adapt to new attack patterns while protecting critical detections and false-positive limits.
Use case template
- Problem: What drifts or changes?
- Protected sets: What must never regress?
- Update cadence: What triggers a micro-update?
- Budgets: Compute/memory limits for update and evaluation.
- Rollout: Canary strategy and rollback thresholds.
- Unlearning: What deletion scopes must be supported?
- Success metrics: Which Frank-7 metrics are primary gates?
Use case: Enterprise knowledge copilot
Your internal knowledge base changes daily. Traditional fine-tuning is too slow and too risky to run constantly. ACI enables micro-updates triggered by document ingestion and feedback, with protected sets that lock down policy and safety behavior. If a change regresses protected scenarios, it does not ship. Rollout happens via canary and remains reversible through rollback and scoped unlearning.
Suggested protected sets
- PII handling and redaction behavior
- Policy refusal scenarios
- Tool-use correctness for critical workflows
- Tone/style constraints for regulated communications
- Hallucination-sensitive prompts
Use case: On-device personalization (smartphones)
Personalization is valuable but privacy-sensitive. ACI supports on-device inference workflows where events are buffered locally and updates are budgeted. Users can request deletion; scoped unlearning provides a way to remove influence of defined user data while verifying collateral drift limits.
Use case: Robotics fleet adaptation
Robots see new environments, new SKUs, and new failure modes. ACI supports edge-first buffering and fleet promotion: updates are evaluated under explicit budgets, promoted through canaries, and rolled back when regressions appear.
Comparison framing
ACI is a system-level product. Comparisons should include operational guarantees: regression gates, rollback, unlearning, and budgets - not only accuracy.
Periodic fine-tuning(full or PEFT/LoRA)
High ceiling quality when you can afford retraining; familiar workflows.
Slow iteration; regression risk; rollback often means retraining; hard to run frequently.
Illustrative run: 12.8 kWh per fine-tune (8 GPUs * 0.4 kW * 4h).
Fast-changing domains, frequent policy changes, fleet/edge constraints.
RAG-only refresh
Fast knowledge updates without changing model weights; low risk to behavior.
Does not fix behavioral drift; tool-use and policy errors persist; still needs evaluation and governance.
Low training cost; but can increase inference cost via retrieval and context length.
When correctness depends on behavior (policy, tone, tool-use), not just facts.
Online SGD / naive continual training
Simple; can adapt quickly.
High forgetting/regression; hard to audit; rollback is hard; can violate safety/quality guarantees.
Compute can be low; operational risk can be high.
Production systems with non-negotiable behaviors.
Replay-based continual learning baselines
Improves stability versus naive SGD; can reduce forgetting.
Operational complexity; data retention/privacy constraints; rollback/unlearning can be difficult.
Cost depends on replay volume; can be heavy on memory/compute.
Privacy deletion requirements, strict budgets, or auditability needs.
ACI (Analytical Continual Intelligence)
Budgeted micro-updates; protected sets; canary rollout; rollback and scoped unlearning; seven-metric contract.
Initial serving overhead can be higher (e.g., ~2.0x inference time without optimizations).
Illustrative micro-update: 0.0025 kWh per event; 5120x less energy per adaptation event vs the fine-tune example.
When organizations want continual adaptation without regressions and with auditable reversibility.
How to summarize ACI vs fine-tuning
Fine-tuning is powerful but expensive to run frequently. ACI aims to replace many fine-tune cycles with governedmicro-updates that are measurable and reversible.
ACI publishes stability and editability metrics because regressions and unsafe behavior are the real cost of continual learning in production.
Security & governance
Governance primitives
Protected sets
Regression suites with tolerances that define non-negotiable behavior.
Budgets
Explicit compute and memory budgets for updates and evaluations.
Canary rollout
Staged promotion to control blast radius and observe regressions early.
Audit trails
Change history and exports for compliance review and incident response.
Scoped unlearning
Deletion requests with defined scope and verification hooks.
API safety practices
Idempotency keys on write endpoints to support retry-safe automation.
Pagination and filtering on list endpoints for scalable operations.
Webhooks for lifecycle events (update created, evaluation complete, canary promoted, rollbackexecuted).
Least-privilege API keys and tenant isolation patterns.
Compliance positioning
ACI publishes stability and editability metrics because regressions and unsafe behavior are the real cost of continual learning in production.
Pricing & packaging
Developer Preview
Early access, sandbox environment, basic benchmarks, and reference integrations.
Team
Core micro-update workflows, protected sets, and dashboards for a single environment.
Enterprise
Multi-tenant governance, audit exports, advanced segmentation, and support for regulated deployments.
Edge & Fleet
On-device agents, fleet promotion workflows, offline-safe operation, and device budget
Pricing that reflects your adaptation reality.
Tell us your deployment (LLMs, robots, edge, mobile) and your governance needs. We'll propose an operating point and packaging that fits your budgets.
API + SDK for continual adaptation (coming soon)
Integrate ACI into your LLM pipeline, robotics stack, or device fleet with a production-grade API surface: idempotent writes, webhooks, and audit-friendly workflows.
What you can expect
REST + JSON API for streams, events, updates, evaluations, protected sets, artifacts, and audit exports.
SDKs for Python (cloud/LLM pipelines) and C++ (edge/robotics) with offline-safe patterns.
Webhooks for update lifecycle events and observability integrations.
Budget objects and policy objects as first-class governance primitives.
Conceptual resource model
Streams
Data windows and event channels that feed continual updates.
Updates
Proposed micro-updates with budgets and protected set associations.
Evaluations
Scorecard results and gated pass/fail decisions.
Protected sets
Regression suites with tolerances.
Artifacts
Vetted outputs produced by approved updates (deployable units).
Unlearning
Scoped deletion requests with verification hooks.
Webhooks
Lifecycle notifications for automation and monitoring.
Developer preview checklist
- Define your protected sets (non-negotiable behaviors).
- Define budgets (compute, memory, latency constraints).
- Choose an operating profile (conservative, balanced, aggressive).
- Integrate canary rollout and rollback thresholds.
- Set up observability for the Frank-7 scorecard.
