pinuxd 0.1.0.post1

Pinuxd — the intellective layer: an operating system for enterprise AI (knowledge graph, governed workflows, cost governor, provable multi-tenant isolation).

Pinuxd

The intellective layer — an operating system for enterprise AI.

Pinuxd is the backbone that decides how an organization uses AI across its data, documents, events, models, and compute — grounded in a knowledge graph, governed end to end, and continuously optimized for accuracy ↑, speed ↑, cost ↓.

Not a chatbot, not a framework, not a model. An operating system: it owns the scheduling, memory, security, I/O, and processes for AI the way a kernel owns them for a computer — so you build on it instead of re-wiring an agent framework + a vector database + a rules engine + a governance bolt-on for the tenth time.

Commercial software — free for 90 days. After the trial a license key is required. For a license key, contact [e-mail].

---

Install

pip install pinuxd

What you get

Plane	Capability
Knowledge graph & semantic layer	A property graph, a business glossary/ontology, entity resolution, and GraphRAG — grounded, multi-hop, cited retrieval that connects facts flat top-k retrieval cannot.
Data & document fabric	Connectors, multi-modal ingestion (text/table/image/audio), incremental ETL into the graph with provenance and provable freshness.
Cost governor	A semantic cache, a reranker, and cheap-first learned-and-gated routing that serves the cheapest path clearing an accuracy bar — with the accuracy floor enforced at execution.
Workflow & event engine	Durable, resumable, event-driven workflows with human-in-the-loop, saga compensation, SLAs, and exactly-once across a crash/failover.
Policy & rules engine	RBAC, rules-as-constraints, living-policy binding, and a machine-checked proof of zero rule violations.
Enterprise hardening	Provable multi-tenant isolation, observability, quotas, deploy/DR, air-gap, and an admin console.

Who it's for — customer use cases

Pinuxd is a horizontal platform. It is built for teams putting AI into production where accuracy, cost, and governance all matter at once — not demos. Typical customers:

• Customer support & IT service teams. Ground answers across your ticketing, roster, and org systems (GraphRAG connects a ticket → the engineer who fixed it → their manager → the SLA), let agents take governed actions (auto-allow small refunds, escalate large ones to a human, deny the rest), and answer most tickets with a cheap model or a cached response so only the hard ones cost more.

• Financial operations & analytics teams. Bind "revenue", "active customer", and "MRR" to the organization's exact definitions via the business glossary, so answers stop drifting with the model's guess — and every figure traces back through lineage to its source record for audit.

• Compliance, legal & risk teams. Encode policy as executable rules; bind a rule to a living policy document so a rephrase reconciles automatically and a contradiction is quarantined for a human — the compliance rule never silently changes because the document did. The rule set is machine-checked for zero violations.

• Field operations & back-office automation. Run long, multi-step processes (inspect → order → approve → dispatch) as durable workflows that survive restarts, resume exactly once, wait for real-world events, and roll back cleanly on failure.

• AI SaaS & platform teams (multi-tenant). Serve many customers on one deployment with provable tenant isolation, per-tenant quotas, full observability, and air-gapped / on-prem operation on CPU or GPU.

When Pinuxd fits: you need grounded, multi-hop answers over your own data; you want to cut model cost without losing accuracy; you must prove that rules and tenant boundaries hold; or you run long-lived, governed processes that cannot lose their place. When it doesn't: a single-prompt chatbot with no data, governance, or cost constraints — you don't need an operating system for that.

Quickstart

from pinuxd import InMemoryGraphBackend, EntityResolver, GraphRAG

g = InMemoryGraphBackend()
r = EntityResolver(g)
t = r.resolve_or_create("T-12", "ticket")
a = r.resolve_or_create("Alice", "engineer")
b = r.resolve_or_create("Bob", "manager")
g.add_edge(t, "fixed_by", a)
g.add_edge(a, "reports_to", b)

# GraphRAG answers a 2-hop question flat retrieval cannot reach
ctx = GraphRAG(g, resolver=r, k_hops=2).retrieve("who manages the engineer who fixed T-12?")
print(ctx.to_text())

Route requests for cost while holding an accuracy bar:

from pinuxd import CostGovernor, Tier

gov = CostGovernor(
    tiers=[Tier("skill", 0, handler=skill_fn), Tier("small", 1, handler=small_llm),
           Tier("large", 8, handler=large_llm)],
    scorer=accuracy_fn, accuracy_bar=0.7)
gov.ask("summarize this ticket")
print(gov.report().savings)     # cheapest path that clears the bar; savings vs all-strongest

Prove your guarantees:

from pinuxd import check_policy, check_isolation
assert check_policy().ok        # zero rule violations over the full state space (machine-checked)
assert check_isolation().ok     # no cross-tenant access over the full state space (machine-checked)

Design principles

• Governed by construction — every data/model/tool call flows through a non-bypassable control plane and is audited; the guarantees that matter are machine-checked, not asserted.
• Parallel-first — expensive work runs concurrently; only critical mutations are serialized.
• Highly available — replicated, quorum-based journal and vector storage; survives a node down; self-heals.
• CPU or GPU — the same code runs on CPU, NVIDIA (CUDA), or AMD (ROCm).
• Vendor-neutral — any model, any vector store, any knowledge-graph engine, via clean seams.

Licensing

Commercial software with a 90-day free trial, then a signed license key (Ed25519; verified offline). The customer CLI ships with the package:

pinuxd-license status               # trial/license status
pinuxd-license install "<KEY>"      # install a purchased key

Enforce it at start-up:

from pinuxd.licensing import LicenseManager
LicenseManager().require()          # raises when a key is required, with the contact address

For a license key or commercial enquiries: [e-mail]

---

© Mohit Deepak Soni. All rights reserved. Proprietary — see the licensing terms.