Free, open, portable AI infrastructure for everyone.
Build AI systems that are inspectable, governed, measurable, replaceable, and not trapped inside a single vendor.
Mission • The Problem • Projects • Architecture • Principles • Get Started
New to Linux of AI? Start with the Start Here guide to choose the right tool for your problem.
You can also inspect the Linux of AI Vendor Exit Demo to see the ecosystem pattern in one deterministic, offline-first example.
The Linux of AI Vendor Exit Demo shows how the ecosystem can help a team evaluate replacing an expensive or locked-in AI model using portable ontology, policy, benchmarking, audit evidence, and cost/outcome measurement.
This demo is deterministic and offline-first. It demonstrates the integration pattern using portable files and reports, including AIMeter OSS-style cost/outcome JSON and AIAuditLog-style audit-event JSONL exports from the model replacement decision.
| Project | PyPI package | Role | Status |
|---|---|---|---|
| AgentForge | agentforge-oss | Agent orchestration | Published |
| PrivateAIStack | privateaistack | Private/local deployment | Published |
| ModelSwapBench | modelswapbench | Model replacement and vendor-exit reports | Published; includes AI Vendor Exit Report |
| OpenOntologyLite | openontologylite | Portable ontology and business meaning | Published |
| AgentPolicyPack | agentpolicypack | Policy-as-code for agents | Published |
| AIAuditLog | aiauditlog | AI audit evidence | Published |
| AIMeter OSS | aimeter-oss | AI cost, usage, efficiency, and outcome measurement | Published |
Linux of AI is not:
- a foundation model;
- a hosted AI provider;
- a compliance certification;
- a legal guarantee;
- a replacement for human review in high-risk workflows;
- proof that any model migration is automatically safe.
It is open infrastructure for building, evaluating, governing, auditing, and measuring AI systems.
If you are new, start here:
- Read docs/start-here.md - Run or inspect examples/vendor-exit-demo/ - Try ModelSwapBench for model replacement decisions
- Try AIMeter OSS for cost and outcome measurement
- Add governance with AgentPolicyPack and audit evidence with AIAuditLog
Linux of AI is a seven-project open-source ecosystem created to reduce vendor lock-in and make practical AI infrastructure available to everyone.
The goal is simple:
No organization should be forced to surrender control of its AI systems, data, costs, policies, or future to a single vendor.
AI is becoming critical infrastructure. But many organizations are discovering that the systems they built are difficult to move, difficult to inspect, difficult to govern, and increasingly expensive to operate.
This ecosystem exists to provide another path.
A path where AI infrastructure is:
Portable across models, providers, and environmentsInspectable instead of hidden behind opaque servicesGoverned through explicit policiesMeasurable in cost, usage, efficiency, and outcomesReplaceable when a model or provider no longer serves the userLocal-first where privacy or control mattersFree and open source for public benefit
This software is intended to remain available to developers, researchers, nonprofits, businesses, governments, students, and communities without placing the core infrastructure behind a paywall.
Organizations adopting AI repeatedly encounter the same pain points.
Applications become tightly coupled to one model provider, SDK, API format, pricing model, or hosted platform. Replacing the provider later can require major rewrites.
A prototype may be affordable, but production usage can grow rapidly. Teams often lack clear controls for routing, budgeting, measuring cost, and comparing alternatives.
Organizations may know they are overpaying or underperforming, but they lack a repeatable way to test another model without disrupting the application.
AI agents can call tools, access data, and make decisions without clear, portable rules governing what they are allowed to do.
Logs are often inconsistent, provider-specific, incomplete, or difficult to verify after the fact.
API success does not necessarily mean business success. Many systems track requests and tokens but not whether the AI produced an acceptable outcome.
Business concepts, relationships, permissions, and actions are frequently embedded directly inside application code, making systems difficult to understand and migrate.
Some organizations cannot send sensitive data to external providers. They need local or controlled deployment options that do not require rebuilding the entire stack.
Linux of AI addresses these problems as one connected ecosystem.
| Layer | Project | What it solves | Repository | PyPI |
|---|---|---|---|---|
| Organizational meaning | OpenOntologyLite | |||
| Defines portable entities, relationships, actions, permissions, and business meaning outside application code | ||||
PyPIAgentPolicyPackGitHubPyPI** AgentForge**GitHubPyPI** PrivateAIStack**GitHubPyPI** ModelSwapBench**GitHubPyPI** AIAuditLog**GitHubPyPI** AIMeter OSS**GitHubPyPI
OpenOntologyLite
│
▼
Portable organizational meaning
│
▼
AgentPolicyPack
│
▼
Portable governance rules
│
▼
AgentForge
│
▼
Portable agent orchestration
│
▼
PrivateAIStack
│
▼
Private and controlled deployment
│
▼
ModelSwapBench
│
▼
Model replacement and economics verification
│
▼
AIAuditLog
│
▼
Portable tamper-evident operational evidence
│
▼
AIMeter OSS
│
▼
Usage, cost, efficiency, and outcome measurement
Each project can be used independently. Together, they form a portable foundation for building AI systems without making one provider the permanent center of the architecture.
Pain point: Organizational knowledge is buried inside source code, database schemas, prompts, and vendor-specific platforms.
What it provides:
- Portable ontology definitions in YAML or JSON
- Typed entities, properties, relationships, and actions
- Permissions and preconditions
- Validation and canonical representation
- Diffing, inspection, documentation, and diagram export
- Local-first and offline operation
Why it matters:
Your organization’s meaning should belong to your organization, not to a proprietary platform.
Pain point: Agent behavior is often governed by scattered prompt instructions and application-specific checks.
What it provides:
- Portable policy-as-code
- Explicit rules for agent actions
- Reusable governance across systems
- A foundation for reviewable and testable agent behavior
Why it matters:
Governance should be visible, portable, and separate from the model itself.
Pain point: Multi-agent systems become tightly coupled to one provider, one orchestration framework, or one pricing model.
What it provides:
- Multi-agent orchestration
- Supervisor and worker patterns
- Model routing
- Budget controls
- Role-based access control
- Policy integration
- Memory options
- Audit logging
- Observability support
- Multiple provider paths
Why it matters:
The orchestration layer should make models replaceable rather than make lock-in stronger.
Pain point: Many organizations need AI capabilities but cannot send all data to external services.
What it provides:
- Local-first AI deployment
- Ollama-backed local models
- FastAPI-based services
- PostgreSQL and pgvector support
- Local retrieval-augmented generation
- Governed code review
- Audit events
- Optional observability
Why it matters:
Privacy, local control, and portability should be practical options, not enterprise luxuries.
Pain point: Teams cannot easily prove whether another model is good enough to replace their current provider.
What it provides:
- Repeatable model comparison
- Outcome-based evaluation
- Cost and latency comparison
- Provider replacement testing
- Evidence for model-routing and migration decisions
Why it matters:
A model should earn its place through measured performance, not remain because switching feels too difficult.
Pain point: AI logs are inconsistent, incomplete, and often locked into provider-specific systems.
What it provides:
- A portable audit-event format
- Local audit tooling
- Hash chaining for tamper evidence
- Consistent operational evidence across AI systems
Important boundaries:
- Tamper-evident does not mean immutable
- A signature does not prove real-world identity by itself
- Audit logs do not automatically create legal non-repudiation
- Using the format does not automatically create regulatory compliance
Why it matters:
Organizations need evidence they can retain, inspect, export, and understand independently of a vendor.
Pain point: Token counts and API bills do not explain whether an AI system is efficient or useful.
What it provides:
- Usage measurement
- Cost calculation using precise decimal arithmetic
- Efficiency analysis
- Outcome tracking
- Budget evaluation
- Provider and model comparison
Important boundaries:
- Missing pricing is never treated as zero
- Calculated cost is not invoice-confirmed cost
- Projected savings are not realized savings
- API success is not automatically business success
- Budgets are evaluated, not automatically enforced
Why it matters:
AI economics should be measured in terms of cost and acceptable outcomes, not tokens alone.
The core software is free and open source under the MIT License.
The ecosystem is designed to keep models, providers, and deployment environments replaceable.
The projects should not claim tests, integrations, security guarantees, compliance, publication status, or verification unless those claims were actually demonstrated.
Organizations should be able to run critical parts of their AI infrastructure locally or inside environments they control.
Models and providers should be selected based on measured outcomes, cost, latency, privacy, and operational needs.
Policies, organizational meaning, audit evidence, and measurements should remain portable when the model or provider changes.
AI infrastructure should not be available only to the largest companies. Smaller organizations, public institutions, researchers, and independent developers should have access to practical alternatives.
Linux of AI is intended for:
- Developers building AI applications
- Teams trying to reduce model-provider dependency
- Organizations facing rising token costs
- Businesses evaluating local or private AI
- Researchers who need inspectable infrastructure
- Nonprofits and public-interest organizations
- Governments and regulated environments
- Platform teams building internal AI capabilities
- Anyone who believes critical AI infrastructure should remain open
Install individual projects from PyPI:
pip install agentforge-oss
pip install privateaistack
pip install modelswapbench
pip install openontologylite
pip install agentpolicypack
pip install aiauditlog
pip install aimeter-oss
Supported Python versions:
Python 3.11–3.13
Visit each repository for project-specific installation instructions, examples, limitations, and documentation.
GitHub organization and public work:
Contributions are welcome.
Useful contributions include:
- Documentation improvements
- Bug reports with reproducible examples
- Tests across Python 3.11–3.13
- Provider adapters
- Model-evaluation scenarios
- Policy examples
- Ontology examples
- Audit-event integrations
- Cost and outcome measurement adapters
- Accessibility improvements
- Security reviews
- Packaging and release improvements
Please read the contribution guidance in the individual project repository before submitting changes.
Free software still requires maintenance.
The long-term goal is to keep the core ecosystem free while supporting sustainability through methods such as:
- Community contributions
- Sponsorships
- Grants
- Research partnerships
- Public-interest funding
- Optional implementation support
- Optional training and consulting
The mission is not to place the core infrastructure behind a paywall. The mission is to keep it useful, maintained, and available.
All projects in the Linux of AI ecosystem are intended to use the MIT License, unless a repository explicitly states otherwise.
AI should expand human capability without forcing humanity into permanent dependence on a small number of vendors.
Linux of AI exists so that organizations can understand their systems, control their costs, govern their agents, preserve their knowledge, replace their models, retain their evidence, and measure whether AI is actually helping.
Free infrastructure. Portable systems. Human control.