00AI deployment for Edge AI and IoT
Edge AI made
ridiculously simple.
LokiAI discovers, validates, and deploys AI models across Edge AI and IoT environments, then tracks what runs, where it runs, and why it fits.
01Intent to execution
From objective to registered outcome
Every deployment moves through the same sequence. Nothing is skipped, and each stage leaves a record you can inspect afterwards.
02Platform architecture
We track state, not just files
LokiAI is deciding what model, which artifact, which runtime, whether it fits, how to deploy, and how to observe it.
03Current Product Proof
Real product evidence on Android
We start where it's hard. Our Android agent proves out QR pairing, authenticated WSS, device credentials, direct HF CDN downloads (GGUF/TFLite), and isolated tenant local inference.
04Wireless deployment
Pair with a QR code. Deploy over the network.
The device authenticates itself, receives a scoped credential and pulls the artifact directly from the CDN. The control plane never proxies the weights.
- 01
QR pairing
The agent scans a short-lived pairing code.
- 02
HTTPS / WSS
Transport is encrypted and authenticated in both directions.
- 03
Device credential
Scoped to one device, revocable, never shared.
- 04
Direct CDN download
The artifact goes straight to the device.
- 05
Local inference
Execution stays in your environment.
- No USB
- No ADB
- No developer mode
- No cable deployment
05Local-first execution
The model runs where the data already is
Running locally is not automatically faster for every workload. It is predictable, private and yours — and for many edge tasks that matters more than raw throughput.
Privacy
Inputs stay on the device. Frames, audio and prompts are not shipped to a third party by default.
Offline operation
Once the artifact is on the device, deployment state and inference survive a dropped link.
Lower recurring cost
You use your existing environment instead of per-token or per-request API billing.
Resilience
A control-plane outage does not stop a device that is already running.
Latency, where it applies
No network hop for compatible local models. Performance depends on the selected runtime and model.
Ownership
The device, the artifact and the runtime are yours, and the record of what was deployed is exportable.
06Applications
What people run locally
These are the workload classes the current runtimes support. Availability depends on the device profile, not on the use case alone.
Offline assistants
On-device chat and summarisation where connectivity is unreliable.
Private AI
Local AI experiences that keep data in the environment where it is used.
Local analysis
Reliable on-device model execution without a cloud dependency.
IoT intelligence
AI capabilities designed for connected IoT environments.
Edge AI
Low-latency local inference for responsive experiences.
Offline workflows
Continuous operation when connectivity is intermittent.
Secure deployment
Verified model delivery with a clear operational record.
AI assistants
Private chat and summarisation that remain available offline.
Local automation
Useful actions derived from trusted, local model output.
07Security and trust
Controls that are enforced, not advertised
LokiAI holds credentials for provider accounts and issues credentials to devices. Both are treated as sensitive by default.
- Tenant isolation — accounts cannot read each other's devices, models or deployment records.
- Encrypted provider keys — stored encrypted at rest and never returned to the browser in raw form.
- Device-scoped credentials — one credential per device, revocable independently.
- Authenticated WebSockets — every socket is bound to an authenticated session and a paired device.
- Strict CORS — the API accepts browser origins from an explicit allowlist.
- Verified model artifacts — deployments reference a pinned file, not a floating tag. See
/security. - Rate limits — discovery, pairing and deployment endpoints are throttled per account.
- Local inference — inference inputs are not routed through LokiAI infrastructure.
08Developers
The parts you can build against
LokiAI is a control plane plus device agents. If you are integrating a new device class or automating deployments, these are the surfaces that matter.
Architecture
Control plane, agent protocol, artifact resolver, deployment engine.
APIs
Account, device, model and deployment resources. Public API in development.
Model formats
GGUF and TFLite today; additional formats under evaluation.
Runtime adapters
A thin interface per runtime: load, warm, infer, release.
Deployment events
State transitions streamed as they happen, with failure reasons.
WebSocket protocol
Authenticated, device-scoped, resumable after reconnect.
09Roadmap
Platform trajectory
Android is the current agent proof. The wider objective spans IoT and Edge AI support, introduced deliberately over time.
Available Now
- › Android device agent
- › Verified discovery
- › WSS telemetry
Beta
- › Linux ARM daemon
- › Raspberry Pi target
- › NIM-assisted ranking
Next
- › IoT support
- › Broader Edge AI support
- › Additional runtimes
Later
- › Partner integrations
- › Expanded runtimes
- › Platform operations
Your environment already exists.
LokiAI gives it intelligence.
Pair a device, verify a model, deploy it wirelessly, and keep the inference local.