Local Knowledge Infrastructure for Sovereign Collaboration

Knowledge systems that remain yours — structured, explainable, and governed without surrendering to platforms or autonomous AI.

• 📐 Schema-first — one YAML drives app, database, UI, and replication
• 🔁 Local-first — P2P sync via Syncthing, no cloud required
• 🧠 Explainable rules — CLIPS-based logic, auditable by design
• 🛡️ Agent governance — structured AI assistance, not autonomy

What Indrayala Is

Indrayala is a local runtime for structured knowledge systems.

It is not a cloud service, a SaaS platform, or an autonomous AI. It is infrastructure: local, open, and under your control.

From a single YAML schema, Indrayala generates a working application — database, UI, replication, analytics, and governance logic included. Applications run locally, replicate peer-to-peer, and accumulate structured knowledge over time.

That knowledge feeds a governance layer: analytics become facts, facts feed rules, rules generate proposals, humans decide.

Indrayala is an architectural counterproposal to centralized opaque AI systems.

Intelligence Through Structure, Not Scale

Modern AI systems increasingly depend on enormous centralized models, vast energy consumption, and opaque reasoning processes.

Indrayala explores a different direction.

Human beings already demonstrate extraordinary intelligence with approximately 20 watts of continuous power consumption. This suggests that intelligence does not emerge from scale alone, but from structure, persistence, embodiment, social coordination, symbolic reasoning, memory, and layered feedback systems.

Indrayala applies this assumption to software architecture.

Instead of treating giant language models as autonomous replacements for human reasoning, Indrayala treats AI as one component inside a larger governance system composed of:

• structured schemas,
• deterministic rules,
• Method-Cards,
• persistent knowledge,
• peer-to-peer synchronization,
• explainable analytics,
• human review,
• and small semantic models.

The long-term goal is not maximal model size.

The goal is maximal intelligence efficiency.

Indrayala therefore treats Nano-model suitability as an architectural quality metric.

If a governance workflow requires massive opaque models to function reliably, the surrounding architecture has failed to sufficiently formalize the problem.

The intended direction is:

human knowledge
    ->
Method-Cards
    ->
structured governance IR
    ->
deterministic rules + compact semantic models
    ->
human review
    ->
operational decision

Large models may assist development and difficult interpretation tasks. But they should not become the hidden foundation of governance.

The architecture aims toward local-first intelligence systems in which most operational reasoning is explainable, inspectable, reproducible, resource-efficient, and ultimately executable on small local hardware.

Schema-Driven Applications

Applications in Indrayala are defined declaratively in YAML.

From one schema, Indrayala generates:

• SQLite database structures, constraints, and generated fields
• Views, predicates, and filters
• UI widgets and context actions
• Replication semantics
• Analytics definitions
• Governance rule bindings

Example (simplified):

yaml

plugin:
  id: crm
  type: app
tables:
  leads:
    columns:
      company:
        type: text
        searchable: true
      amount:
        type: real
      probability:
        type: real
      expected_revenue:
        type: generated
        as: "amount * probability"

From Data to Knowledge

Indrayala does not separate data, analytics, and reasoning. They form a single layered knowledge model.

Structured data lives in schema-defined local databases.

Analytics run over that data declaratively, produce persistent snapshots, and make trends inspectable over time. The same predicate system used for table filtering governs analytics scope — no parallel query semantics.

Governance rules can reason over both: current operational rows and persisted analytics snapshots become facts in a rule-evaluation environment. The result is not a dashboard — it is a proposal.

text

operational data
  + analytics snapshots
  + proposed changes
  → CLIPS rule evaluation
  → explainable proposal
  → human decision

This is the knowledge model Indrayala is built around.

Method-Cards

Method-Cards let domain experts author governance rules in plain language.

A Method-Card describes a domain situation and its consequences: a lead without follow-up, a budget signal in a conversation, a metric that has crossed a threshold. Each card represents one to three rules.

A compiler translates Method-Cards into executable CLIPS logic. Rules may contain deterministic Python predicates, or AI-assisted predicates via PydanticAI — explicitly labeled, individually disableable, and cached for reproducibility.

text

Method-Card (.md)
  → Compiler → IR → CLIPS Rules
                      ├── deterministic predicates (Python)
                      ├── AI-assisted predicates (PydanticAI, cached)
                      └── pure CLIPS inference

The Method-Card remains the authoritative, human-readable source. If a rule produces an unexpected proposal, the user can read the card that generated it and understand why.

Agent-Friendly, Human-Governed

Indrayala is designed to cooperate with AI agents — but never to be controlled by them.

Agents may propose, analyze, explain, generate Method-Cards, and prepare changes. All proposals pass through a human review step before execution. Agents do not modify operational data directly.

Indrayala acts as a governance layer between AI systems and the user.

Peer-to-Peer Replication

Application data replicates via changesets — without a central server.

• Full or selective dataset replication
• Offline-first synchronization
• Single-record exchange
• Conflict visibility and import history

Replication is peer-to-peer. Each node remains autonomous. No cloud provider or central coordinator is required.

Architectural Principles

• Local-first over cloud-first
• Schema as single source of truth
• Declarative over imperative
• Explainability as an architectural property
• Human governance over autonomous execution
• Peer-to-peer instead of platform dependency
• Open formats for long-term ownership

Inspired by Indra’s Net: each node reflects the whole — no center required.

No system component may silently acquire authority.

Technology

• Python 3.10–3.13
• PySide6 / Qt
• SQLite / APSW
• YAML schemas
• CLIPS (rule engine)
• PydanticAI (AI-assisted predicates)
• Syncthing / P2P transport
• LibreOffice UNO integration

What Indrayala Is Not

• Not SaaS
• Not a cloud platform
• Not autonomous AI
• Not vendor lock-in

It is infrastructure.

License

Mozilla Public License 2.0 (MPL-2.0) — see LICENSE for details.