ecOS >_ CogPOSIX

ecOS >_ CogPOSIX

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.

Inside the runtime Community runtime: Apache-2.0
/ /

Build a new operating system.

ecOS >_

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 path to our OS OS in development · Planned recipes: Apache-2.0
Your compute.
Your control.

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
  1. 01Your query

    Ask for relevant evidence.

  2. 02Local encoder

    Represent the query as a vector.

  3. 03ETE-X search

    Bound candidates. Refine possible winners.

  4. 04Optional reranking

    Score the selected documents.

  5. 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.

Explore distributed intelligence

From interface to operating system

The foundation is running.
Now build on it.

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.

R1 evidence
Working / R2

Linux shared memory

Sealed inputs and immutable output snapshots passed by file descriptor. Not end-to-end zero-copy.

Memory contract
Experimental / R3

Real local inference

A pinned ONNX CPU model, bounded worker exchanges, artifact checks and crash recovery.

R3 evidence
Next / R4 + R5

Scheduling & packages

Resource accounting, scheduling policy and reviewed model packages. Applications and OS installation follow.

Full roadmap
30Linux Rust tests passed
Rust + CWorking application interfaces
Local CPUVerified ONNX inference
Read the validation report

For builders

Less speculation.
More execution.

Explore the contract with the deterministic mock, then run the real ONNX worker. No API key, account or hosted inference service required.

Open the developer guide
Local mock / no API key
cargo build --workspace --offline
node scripts/smoke.mjs

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.

Community and service boundaries

Built to be built on

Open code.
Clear commitments.

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.

Licenses by component
Component licensing and availability
ComponentLicense / termsScope & availability
CogPOSIX headers, SDK & reference codeApache-2.0Listed software, schemas, examples and tests. Experimental ABI.
ecOS community runtimeApache-2.0Listed project-owned runtime and backend code. Broader policy and diagnostics remain roadmap work.
Optional ETE-X retrieval componentCC BY-NC-ND 4.0Separately licensed original engine, worker, mapper and marked tests. Explicit opt-in build; commercial permissions are separate. Component guide.
Specification & public documentationCC BY 4.0Attribution to ecOS and CogPOSIX contributors. Original embedded code and schemas also offered under Apache-2.0.
Community OS recipes & integrationApache-2.0 PlannedProject-owned code when explicitly released. No installable ecOS image today.
Community distributed fabric & basic data adaptersApache-2.0 PlannedProject-owned distributed execution and baseline policy when explicitly released. Independent of LOGFORCE.
DuckDBMIT Candidate integrationStructured analytics and evaluation. No DuckDB binaries or datasets included.
Qdrant open-source engineApache-2.0 Candidate integrationVector retrieval and governed collections. No Qdrant binaries included; cloud offerings have separate terms.
Public event schema & basic LOGFORCE bridgeApache-2.0 PlannedOpen contract and basic adapter only; not the proprietary engine.
LOGFORCE intelligence, models & enterprise sensorsProprietary / separate agreementNot included. No rights granted by this repository's open licenses.
Enterprise modules & premium feedsSeparate commercial agreementsOptional proprietary distribution; data and service rights defined separately. No current support SLA.
Linux, dependencies, firmware & datasetsOriginal component licensesNo umbrella relicensing. OS distribution requires an inventory and applicable notices/source delivery.
Third-party model weightsOriginal artifact termsThe ETE-X source package includes two attributed Apache-2.0 demonstration models. MNIST remains a separate optional download. Model identities and scope.
Website & document readerApache-2.0 / CC BY 4.0 / MITProject 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.
Logos & brand artworkReserved artwork rightsShown 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.

Explore the repository

GitHub Discussions

Propose ideas, ask questions others can learn from and discuss architecture before turning a proposal into development work.

Join the discussion

GitHub Issues

Report reproducible bugs with expected behavior, actual results and environment details. Track agreed development tasks here; never include secrets or private data.

Report an issue

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.

Documentation