Everything Eldric does.

One binary. Your whole AI platform.

A single operating system

Eldric runs as one self-contained service that hosts every capability — chat, inference, retrieval, agents, data, messaging, science, training — as built-in modules. Install it, browse to the chat shell, and the platform serves everything. No stack to assemble.

Modules for what each node does

Choose what each machine in your cluster runs — inference, data, edge, and the rest — with checkboxes in the admin console, not startup flags. A plain install serves the full platform out of the box.

Multi-tenant isolation

Every stored file, document, session and memory carries a tenant. The platform refuses cross-tenant access at the boundary, so one customer's data can never surface in another's — enforced server-side, on every request.

Capability-gated access

Every action is gated by an explicit capability, not a loose role string. Compose your own named roles — "Auditor", "Lab tech", "Finance" — scoped to a tenant, and every denied request tells the caller exactly what permission was missing.

Runs entirely on your hardware

Nothing leaves your network. The platform, the models, the memory and the documents all live on machines you control — the whole point of an on-prem AI operating system.

Every model, local or cloud, one endpoint.

Thirty-plus model backends

Connect local runtimes (Ollama, vLLM, TGI, llama.cpp, MLX) and cloud APIs (OpenAI, Anthropic, xAI/Grok, Together, Groq, DeepSeek, Mistral, Cohere and more) through one unified layer. Add, switch and test backends from the admin console.

Native inference, no external runtime

Eldric serves inference natively, loading GGUF and xLSTM models directly — no Ollama, no vLLM, nothing extra to install. Multi-GPU tensor splitting, speculative decoding and continuous batching are built in.

Cloud aggregation with fallback

One OpenAI-compatible endpoint federates every cloud provider you connect. Requests route to the right backend by model name, with priority ordering and automatic fallback when a provider is unreachable.

Real streaming, end to end

Answers stream token-by-token from the model all the way to your client, through the same secure path every request takes. Works identically across local and cloud backends.

Native tool-calling

Tool calls route through each model's native tool-calling API where the backend supports it, with an automatic fallback for models that don't — fewer half-finished tool runs and more reliable agent behaviour on long chains.

Drop-in OpenAI compatibility

Point any OpenAI-SDK client, OpenWebUI, or your own code at Eldric's endpoint. Chat, completions, embeddings, models, streaming, vision and tools all work as drop-in replacements.

Every request to the right place.

Eight load-balancing strategies

Round-robin, least-connections, least-latency, weighted, priority failover, IP-sticky, A/B and random. Pick the strategy that fits your fleet; the platform spreads load across your nodes accordingly.

AI-controlled routing, when you ask

Beyond the algorithmic strategies, an optional advisory or autonomous mode lets a model make the routing call in real time. Off by default — you turn it on where it earns its place.

Intent classification

The platform recognises what each request actually needs — plain chat, retrieval, an agent, a science lookup, a data operation — and dispatches it to the right capability automatically.

Tool answers fired server-side

Ask a forecasting, natural-hazard or drug-interaction question and the platform recognises the intent and runs the right tool itself, returning a real sourced result. It works the same on a local model or a cloud one, because the dispatch happens server-side rather than relying on the model.

Theme-aware routing

Medicine, legal, code, finance, science, creative and general each carry their own default model and per-rule overrides, so a legal question and a coding question can land on the model best suited to each.

Ensemble answers

For high-stakes questions, fan one request out to several models and synthesise the answers through a designated model — more than one opinion, reconciled into one response.

Storage, retrieval and memory that stay yours.

Multi-tenant file storage

Each tenant gets an isolated storage namespace with quotas and access controls. Any file you upload becomes usable by chat, agents and retrieval across the platform.

Vector search / RAG

Ingest documents and search them semantically, with lexical and vector scoring fused into one ranked result set. Proper names, product names and IDs return exact matches; documents re-embed automatically when you edit them.

Matrix Memory

A compressed associative memory that gives fast, generalising recall alongside the exact vector store, in Eldric's compact portable .emm format. Both are queried together and the results merged.

Resumable large-file upload

Upload large files in chunks straight from the browser, with progress and resume if the connection drops. Incomplete uploads are swept automatically after a time-to-live.

Replication

Keep vector storage, matrix memory and file storage in sync across data nodes, with per-target throttling and secure transport. Choose the consistency level that fits — from background async to majority-quorum.

Backup and disaster recovery

Snapshot controller state, vector storage, matrix memory, tenant configs and licensing, each verified by checksum. Restore is idempotent, so recovery is repeatable and safe.

Grounded answers, out of the box.

RAG on by default

Upload PDFs, DOCX, code, CSVs, audio, video or sensor streams, ask grounded questions, and read citation chips that point back to the source passages. Retrieval is on out of the box in 5.0 — no setup to get grounded answers.

Guided knowledge-base setup

A wizard walks you through standing up a knowledge base — pick the source, set chunking and embeddings with sensible defaults, and the platform ingests your documents. Semantic search over your own content in a few steps.

Agentic retrieval

For questions a single lookup can't answer, an agent iterates reason-act-observe up to a cap you set, calling retrieval, web fetch, file read and any registered tool until it has a grounded answer.

Query decomposition

Complex questions are rewritten into a set of sub-questions and answered in parallel, then recombined — so a multi-part question gets a complete, structured response.

Learns from your work

An opt-in learning loop reviews completed sessions on a schedule you set and distils repeatable procedures into named skills you review before anything is kept. On by your choice, nothing autonomous, nothing leaving your cluster.

Agents that do the work, not just chat.

Fifteen specialized agent types

General, Researcher, Coder, Validator, Planner, Analyst, Explorer, Runner, Searcher, Database, Learner, Network, Spider, Email and Ansible. Each agent carries its own constrained tool set, so it does exactly the job it's built for and nothing else.

Agentic RAG

Agents iterate through reason, act and observe against your own knowledge bases, following references and refining the answer until they've grounded it in your sources rather than guessing.

Multi-tenant sessions

Every agent session is scoped and isolated to its tenant, with conversation history preserved. One installation serves many teams; no team ever sees another's work.

Orchestration patterns

Multi-step workflows chain agents together sequentially, in parallel, as a map-reduce, or as a dependency graph — so a real task gets broken down and executed, not just answered.

Agent Builder

Describe the agent you want in plain language and Eldric designs it, generates its tools, prompts and test cases, and runs sandboxed test runs before you deploy — the "AI that builds AI", right in the chat shell.

Agent sharing & marketplace

Share an agent you built inside your tenant with one click, publish it to the cluster marketplace for an admin to review, and edit it in place with versioning. Every change is validated in a sandbox before it goes live.

Every channel your people already use.

Seven messaging protocols

Email (IMAP/SMTP), SMS, WhatsApp, Signal with end-to-end encryption, Microsoft Teams, and XMPP, plus VoIP — all flowing through one unified message envelope so a conversation reads the same wherever it started.

AI voice calls

A full voice pipeline handles telephone-style calls: AI-answered and AI-placed calls, voicemail with automatic transcription, IVR menus, call transfer, hold and DTMF, with encrypted media for calls that need it.

AI auto-response with approval

Eldric can draft replies to incoming messages in your voice, then hold them in an approval queue so a human signs off before anything is sent. Automation without losing the last word.

Real-time inbox

Incoming messages arrive live across every protocol, are stored on your own hardware, and become searchable the moment they land.

Semantic message search

Search your entire message history by meaning, not just keywords, across every connected channel at once.

Eldric in your inbox

Give Eldric its own address, number or handle on your domain and Cc it into any thread; it answers in-thread under that identity, with the same authentication and tenant scoping as the chat shell.

Hear it, transcribe it, search it, speak it back.

Speech-to-text

High-quality transcription of audio via Whisper and Faster-Whisper, in batch or streaming, for dictation, meeting notes, accessibility input and voicemail.

Text-to-speech

Natural speech synthesis through Piper, ElevenLabs and OpenAI voices, with streaming output for responsive playback.

Video transcription & scene detection

Pull the spoken content out of video, extract keyframes, and detect scene cuts — turning recordings into searchable, structured content.

Voice chat

Speak a question and hear the answer: audio in, transcription, model, synthesis, audio out, in a single round trip suitable for mobile.

Multimedia RAG

Audio and video are indexed and searchable alongside your documents, so a spoken sentence in a recording is as findable as a line in a PDF.

Real answers from real sources, never fabrication.

Sixteen-category source registry

One unified catalogue spanning open-access papers, space, particle physics, genomics, neuroscience, medical, chemistry, earth, climate, astronomy, archaeology, legal, patents, funders, industry and custom sources. Admins enable the ones you need; users only ever see what's switched on.

140+ scientific data sources

NASA, ESA, JWST, CERN, LIGO, USGS earthquakes, NOAA, Ensembl, ENCODE, Allen Brain Atlas, Clinical Trials, WHO, OpenFDA, PubMed and many more, all reachable through the same interface.

Bioinformatics

DNA, RNA and protein sequence analysis, translation, alignment, BLAST search and variant calling.

Pharmaceutical & CRISPR

Compound lookup, molecular docking, ADMET prediction and AlphaFold structures; CRISPR guide-RNA design, off-target analysis, and base and prime editing.

LIMS with compliance

Sample tracking, experiment management and audit trails, with GLP and FDA 21 CFR Part 11 compliance modes for regulated labs.

Honest "source not wired"

Ask about a source that isn't connected and Eldric tells you so plainly, with a hint for the admin — it never invents a result. You add a custom source through the registry with no code changes, and the next query uses it.

Train your own models, on your own hardware.

Six training backends

Unsloth, Axolotl, TRL, DeepSpeed, MLX and llama.cpp all run natively inside Eldric. Fine-tune on a single Apple Silicon Mac, a multi-GPU server, or anything in between — same workflow, your choice of engine.

Eight training methods

LoRA, QLoRA, SFT, DPO, RLHF, PPO, full fine-tune and distillation. Pick the method that fits your data and budget, from a quick low-rank adapter to a full alignment run.

Training chains

Build a pipeline as a visual chain of nodes: data source, AI generator, trainer, evaluator. Templates for QA pipelines, code QA and alignment get you started; wire your own steps together for repeatable runs.

Latent-reasoning techniques

Advanced reasoning approaches (continuous-thought, self-taught reasoning, pause tokens, hidden chain-of-thought and dynamic sparse attention) for teams pushing model quality beyond standard fine-tuning.

Federated learning

Train a shared model across many nodes without moving the data. Each node trains locally on its own data; only model updates are aggregated. Opt in per tenant, off by default.

Smart-home and factory-floor sensing, in one place.

Consumer smart home

Connect Netatmo weather and security devices, plus HomeKit and Matter gear. Pair devices and read or write their attributes through one unified interface — no separate hub.

Industrial protocols

Talk to PLCs, SCADA and DCS systems over OPC-UA, to legacy equipment over Modbus TCP/RTU, and to plant-floor gear over MQTT Sparkplug B. The protocols your existing hardware already speaks.

Alarm management and historian

Standard industrial alarm handling plus a built-in time-series historian, so live and historical tag values are captured, buffered and queryable without a bolt-on system.

OEE analytics

Overall Equipment Effectiveness calculation and manufacturing recipe management, with store-and-forward buffering that keeps data flowing even when the link to the central cluster drops.

Predictive maintenance

Live sensor readings feed Eldric's memory, and anomaly detection turns them into maintenance scores — early warning of equipment trouble, generated on your own infrastructure.

Structured-ML workloads, run natively.

Runs natively in Eldric

Structured-ML workloads execute directly inside the platform on the xLSTM model family — no separate service to deploy or maintain. Four workload categories, one engine.

Policy execution

Closed-loop control policies drive real-time decisions over WebSocket, Modbus, OPC-UA and MQTT Sparkplug B, with a safety fallback that engages automatically if a control step misses its deadline.

Time-series forecasting

Forecast future values from a window of telemetry — demand, load, sensor trends — for planning and early warning, without shipping the data off-site.

Vision-language encoding

Turn images and visual scenes into machine-usable representations for perception and search tasks.

Associative retrieval

Fast approximate recall that returns the closest stored match in microseconds on CPU alone — no GPU required — for rapid lookup and fuzzy matching.

Many agents, working as one.

Six coordination topologies

Arrange agents as a hierarchy, a peer-to-peer mesh, a ring, a star, a full mesh or a hybrid. Match the shape of coordination to the shape of the problem — and change it at runtime.

Goal-driven execution

Hand a swarm a goal and let its agents and topology work out the steps. Every reasoning step is logged, so you can see exactly how an answer was reached.

Automatic best-agent selection

The swarm tracks the health and load of its agent pool and routes each task to the best-placed agent, keeping work balanced across the cluster.

Opt in per tenant

Multi-agent swarms are enabled per tenant from the admin console — on where you want the capability, invisible where you don't.

Run it like production infrastructure.

High availability

Run multiple controllers as a consensus cluster that forms, replicates and fails over on its own. If the lead controller goes down, another takes over — the cluster keeps serving.

Multi-site federation

Run more than one Eldric cluster and have them act as one platform. Choose a regional-aggregator hierarchy or a peer mesh across sites, with cross-site routing and federation dashboards built in.

Rolling updates

Upgrade the whole cluster with zero-downtime orchestration: drain in-flight requests, snapshot state, install, verify, restart and validate — one node at a time, automatically.

Backup and disaster recovery

Snapshot controller state, vector storage, memory, tenant configs, license and plugins, each blob checksum-verified. Restore is idempotent, so recovery is repeatable and safe.

Certificates, done for you

A built-in certificate authority plus automatic Let's Encrypt issuance and renewal. Generate, deploy and rotate certificates cluster-wide from the operator console.

Replication, webhooks, tracing, discovery

Replicate data between nodes; fire signed outbound webhooks on events; export traces and metrics to your existing observability stack over OpenTelemetry; and let nodes find each other automatically on the local network.

One secure front door.

TLS gateway

Every external request enters through a single hardened edge with TLS termination, so nothing inside your cluster is exposed to the outside directly.

API-key auth

Issue and revoke per-client keys; every call is authenticated before it reaches a model.

Rate limiting

Global, per-IP and per-key limits keep one noisy client from starving the rest.

Built-in web chat

A browser chat shell is served straight from the edge — your people can start using Eldric without installing anything.

Plugin host + marketplace

Extend the platform with server-side and browser-side plugins; browse, install and update them from a catalog with signature and manifest checks.

Use it however your people work.

Browser chat

A full-featured chat interface with model picker, streaming answers, conversation history and grounded tool results — nothing to install.

Native macOS app

A native desktop client with the full chat and configuration surface, auto-updating.

Command line

A terminal client for interactive use, single-prompt runs and scripting.

OpenAI-compatible API

Point any tool that speaks the OpenAI API at Eldric — OpenWebUI, SDKs, your own apps — and it just works.

iOS

Eldric on the phone, against your own cluster.

Built for serious deployments.

Multi-tenant isolation

Every tenant's data, sessions and knowledge stay walled off from every other tenant, enforced at the platform level.

Role-based access

Assign roles and permissions so people see and do only what they should; admins compose their own roles.

Per-tenant branding

Give each tenant its own theme, logo and look in the chat shell.

Flexible licensing

Tiered licensing scales from a single node to a large private cluster, activated from a signed license file — no phone-home required.

Deployment postures

Ready-made shapes for going fully private, for datacenter scale, and for cloud providers reselling AI services.

A platform you can build on and operate.

OpenAI-compatible surface

Build integrations against a familiar, documented API — chat, models, embeddings and more.

Plugin SDK

Write your own tools, filters and virtual models and drop them into the platform.

Admin console

Manage nodes, models, tenants, storage, routing and access from one web console.

Operator-friendly

Rolling upgrades, backup and restore, certificate management and health monitoring are built in, not bolted on.

On the roadmap.

Named directions, not dated promises. What's below is where the platform is heading; everything above is what you get today. For the full 5.0.x roadmap, see what.s next in 5.0.x.

Manage the whole cluster from one console rolling out

Assign roles to each node and manage cluster-wide model storage from a single admin console.

Eldric learns reusable skills from your sessions rolling out

Opt-in and off by default, Eldric can distil repeatable procedures from how you work and propose them back to you for review before anything is reused.

Per-token grounded recall

Extending grounded memory so answers stay anchored to your knowledge throughout a long response, not just at the start.

Native inference everywhere

Continuing to make native model serving a first-class part of the platform on more hardware targets.

Broader language and client coverage

More of the interface and docs in more languages, and more native clients.

Deeper scientific and industrial connectors

Widening the catalog of wired scientific sources and industrial devices over time.