The open OS bringing a new POSIX-inspired interface to machine intelligence.
ecOS is built around CogPOSIX, a system-level execution interface for running AI models as native computing resources, designed for performance and security.
Traditional AI application compared with an ecOS application
ApplicationsRequest AI capabilities, not implementations
ProductivityDevelopmentAnalyticsCreativeand more
↓
CogPOSIXA system contract for AI computation (inspired by POSIX)
Standardized interface
Capability-based
Implementation-agnostic
↓
ecOSThe operating system determines which implementation may satisfy the request, where it executes, which resources it may use, which data it may access, and whether it may leave the machine at all.
Core Principles
Intelligence should execute as close to the data as possible
Cloud computation is not the default
Every transition across a trust boundary is a policy decision
Distribution is not automatic
Our OS. Our system contract.
Many models. One system interface.
ecOS >_ and CogPOSIX are being developed together: a new operating system and its AI execution contract. Applications use CogPOSIX to access controlled intelligence as a system resource, across model classes.
>_
Build against a contract.
CogPOSIX
Open a model. Share typed data. Submit a job. Manage its lifecycle. A POSIX-inspired execution interface makes controlled models part of the application stack, beyond a single provider or model class.
Meet CogPOSIX →Code: Apache-2.0 · Specification: CC BY 4.0[ ]
Make local the default.
ecOS runtime
A task solved on your machine needs no remote inference tokens. The runtime coordinates model execution, data ownership and jobs, starting with a working Linux CPU backend.
We are building our own OS architecture around local intelligence, with applications, controlled models and recovery designed together. The current runtime prototype runs on Linux; the complete installable OS is in development.
The right tool may be a vision model, a signal processor, a language model or a conventional algorithm. The design puts task suitability and local control first. It does not make every problem an LLM request.
ETE-X · Early Termination Encoding
Find the evidence. Keep it local.
A CPU-only retrieval engine built to help make Sovereign AI practical. Search an approved local corpus with compact models, and return the documents, scores and source identities your application needs.
ETE-X checks which candidates can still reach the best results, then refines the possible winners against their original vectors. An optional second model reranks the selected documents. Provisioned inference runs on the CPU, without a hosted model or an API key.
In ecOS >_ CogPOSIX, retrieval becomes an explicit capability with bounded inputs, a managed job lifecycle and typed results. A CogSheet™ semantic mapper provides the application integration boundary; connecting it to the live sheet is the next application step.
ecOS >_ CogPOSIX Local corpus · explicit configuration · managed execution
01Your query
Ask for relevant evidence.
02Local encoder
Represent the query as a vector.
03ETE-X search
Bound candidates. Refine possible winners.
04Optional reranking
Score the selected documents.
05Typed results
References, scores and provenance.
A local retrieval pipeline. Dense-search scores and reranker scores remain separate and inspectable.
Useful on everyday CPUs.
Compact non-autoregressive models and CPU search support a practical local deployment. The reference profile includes two ONNX models and a sixteen-document synthetic corpus for a reproducible first run.
Evidence you can reuse.
Document identifiers, corpus and model identities, execution metadata and typed failures give downstream applications a clear result contract. Exact ranking refers to the declared vector scorer; semantic quality is evaluated for each task.
An optional capability.
The native backend and semantic mapper come with regression tests. ETE-X is enabled explicitly and separately licensed; the community core keeps its existing license and independent default build.
Developer integration for Linux x86-64. Standalone research measurements and native functional tests have distinct scopes; the technical guide explains the numerical contract and deployment requirements.
Planned capability
Distributed intelligence, when you want it.
Local-first does not mean isolated. ecOS is designed to let approved workstations, AI nodes and edge devices share execution within a controlled policy domain, only when distribution has been explicitly enabled.
ecOS policy domain
Workstation
GPU / NPU
AI node
GPU / NPU
Edge node
Accelerator
CogPOSIX fabric
Shared compute. Explicit boundaries.
Applications keep a common capability contract. Policy controls node participation, authentication, model availability, data classes and execution locality. Another machine is always another execution boundary, even on your own network.
Shared knowledge. Separate permission.
Candidate services such as DuckDB and Qdrant could support analytics, retrieval and evaluation across approved datasets. Access to data does not authorize training on it. Model improvement requires its own governed, evaluated workflow.
Distributed execution and database integration are planned, not available in the current runtime. The standalone local experience remains independent of this feature.
The developer prototype connects Rust and C applications to local inference. Its pinned digit-classification worker is joined by an optional ETE-X document-retrieval profile. Model packages, broader policy and the installable OS remain the next chapters.
Working / R1
Execution contracts
Rust and C clients, typed handles, asynchronous jobs, cancellation and resource cleanup.
Run the ONNX validationnode scripts/validate-linux.mjs --onnx
Build from a source checkout with Rust, a C compiler and Node.js. ONNX validation also requires Docker; its initial image build downloads dependencies and a pinned model, then tests run offline. The runtime is a developer prototype; the OS installer is still on the roadmap.
An open ecosystem
Independent at the core. Connected by choice.
Sovereignty includes the freedom to choose your security providers. LOGFORCE is the planned optional connection for proprietary analytics and enterprise security, through an open integration contract.
Open integration. Real choice.The planned event schema and basic bridge will use Apache-2.0 when released. The community runtime remains independently usable, and other analyzers can implement the same contract.
LOGFORCE stays separately licensed.Its intelligence, models, enterprise sensors and commercial modules remain proprietary under their own agreements. No LOGFORCE engine or integration is included in the current runtime.
Apache-2.0 for the community core. CC BY 4.0 for the public specification and documentation. Optional ETE-X uses CC BY-NC-ND 4.0; third-party models and other LOGFORCE components retain their own terms.
Not included. No rights granted by this repository's open licenses.
Enterprise modules & premium feeds
Separate commercial agreements
Optional proprietary distribution; data and service rights defined separately. No current support SLA.
Linux, dependencies, firmware & datasets
Original component licenses
No umbrella relicensing. OS distribution requires an inventory and applicable notices/source delivery.
Third-party model weights
Original artifact terms
The ETE-X source package includes two attributed Apache-2.0 demonstration models. MNIST remains a separate optional download. Model identities and scope.
Website & document reader
Apache-2.0 / CC BY 4.0 / MIT
Project code: Apache-2.0. Prose and generated concept illustration: CC BY 4.0 where copyright applies. Marked: MIT. DOMPurify: Apache-2.0 option. Third-party notices.
Shown to identify the project. No open artwork or trademark license; separate permission may be needed for reuse.
Commercial use of the Apache-2.0 and CC BY 4.0 material is permitted under those licenses. Community use creates no paid-service contract. Full license scope · Community terms · Brand policy
Build together
Your next idea belongs here.
Meet the community, challenge a design or bring a working example. Choose the right place to start.
Slack
Introduce yourself, ask for help, share demos and collaborate with other builders. Bring lasting answers and decisions back to the public project discussions.
Open Slack ↗Workspace membership may be required. This link opens Slack sign-in.
GitHub Repository
Explore the source code, run the prototype and contribute changes through pull requests reviewed by the maintainer.
Report reproducible bugs with expected behavior, actual results and environment details. Track agreed development tasks here; never include secrets or private data.
Community membership does not grant repository write access. Contributor roles and changes to the official project require maintainer approval. Contribution guide · Community terms
The next layer is open
Build intelligence into the system.
Help shape the interface between applications, controlled models and the machines they run on.