Indrayala — Infrastruktur, keine Plattform

Viele Werkzeuge versprechen Kontrolle.
Und liefern Komfort.

Das ist nicht dasselbe.

Kontrolle bedeutet:
Du weißt, wo deine Daten sind.
Du weißt, wer Zugriff hat.
Du weißt, was ein System in deinem Namen tut —
und was nicht.

Die meisten modernen Plattformen können diese Fragen nicht beantworten.
Nicht weil sie es verbergen wollen.
Sondern weil sie so gebaut sind,
dass die Frage gar nicht vorgesehen ist.

Indrayala ist anders gebaut.

Nicht als Versprechen —
sondern als Entscheidung, die sich durch jede Schicht der Architektur zieht.


Indrayala ist keine Anwendung.

Es ist Infrastruktur —
eine lokale Laufzeitumgebung für strukturierte Wissenssysteme.

CRM läuft darin.
Buchhaltung läuft darin.
Forschungsdatenbanken laufen darin.
Projektkoordination läuft darin.

Was auch immer strukturiertes Wissen braucht und
Kontrolle darüber behalten will.


Intelligenz durch Struktur, nicht durch Größe

Das menschliche Gehirn benötigt ungefähr 20 Watt — und erzeugt
Sprache,
Erinnerung,
Bedeutung,
Entscheidung.

Größe allein erzeugt noch keine Intelligenz.
Struktur dagegen konserviert und verdichtet sie.

Wie Skelett und Körperbau kompilierte Intelligenz sind —
trägt die Struktur, bevor die Bewegung beginnt —
so soll in Indrayala möglichst viel Intelligenz in
Schemas,
Regeln und
Wissensbasen stecken.

Damit die eigentliche Inferenz einfach sein kann.

Das Ziel ist nicht maximales Potenzial.
Das Ziel ist maximale Effizienz der Intelligenz.

Wenn das nicht klappt —
wenn große Modelle nötig werden, damit das System funktioniert —
dann hat Indrayala ein wesentliches Ziel verfehlt.

Deshalb ist jede Design-Entscheidung in Indrayala dieselbe Frage:
Wie viel Intelligenz lässt sich in die Struktur verlagern —
bevor ein Modell gefragt wird?


Replikation ohne Plattform

Deine Daten liegen lokal.
Immer.

Wenn du mit jemandem zusammenarbeitest,
kannst du gezielt replizieren:
diesen Lead,
diese Dokumente,
diesen Kontext.

Oder du lässt die Replikation mitlaufen —
alle verbundenen Peers bleiben automatisch aktuell.

Beides funktioniert.
Beides bleibt sichtbar.
Beides liegt bei dir.

Nicht über fremde Server.
Nicht durch Hintergrundinstanzen, die du nicht kennst.

Die Replikation ist kein zukünftiges Konzept mehr.
Sie läuft bereits.


Ein Beispiel

Du arbeitest an einem Angebot für einen potenziellen Kunden.

Im CRM innerhalb von Indrayala ist der Lead erfasst:
Kontaktdaten,
Gesprächsnotizen,
Verlauf,
Aufgaben,
verknüpfte Dokumente.

Du übergibst deiner Kollegin nicht eine Datei —
sondern den relevanten Wissenskontext.

Sie arbeitet offline weiter.
Ergänzt Notizen.
Passt das Angebot an.

Später gleicht ihr ab:
nachvollziehbar, selektiv, bewusst.

Nicht durch irgendeinen fremden Server.
Nicht durch eine Blackbox-Synchronisation.


Wissen, das sich selbst beschreibt

Indrayala speichert nicht nur Daten.
Es speichert Zusammenhänge.

Ein Lead kennt seine Dokumente.
Ein Dokument kennt seine Geschichte.
Eine Analyse kennt ihre Quellen.

Analytics ist eine weitere Wissensquelle —
keine separate Anwendung,
kein externes Dashboard.

Beobachtungen werden zu Fakten.
Fakten werden zu Regeln.
Regeln werden zu Empfehlungen.

Und jeder Schritt bleibt lesbar.


KI, die fragt — nicht entscheidet

Ein MCP-Interface ist in Arbeit.

Im ersten Schritt: lesend.
Ein KI-Agent kann
Wissen abfragen,
Strukturen erkunden,
Kontext aufbauen.

Aber nicht schreiben.
Nicht noch.

Wenn Schreiben kommt, kommt es durch ein Staging-Modul:
eine CLIPS-Wissensbasis, die jede Änderung bewertet.

Unbedenklich — wird freigegeben.
Kritisch — geht zum Menschen.
Abweichung — wird gewarnt.

Kein KI-Agent handelt still.
Kein System übernimmt schleichend Verantwortung.

Der Mensch bleibt im Weg — absichtlich.


No system component may silently acquire authority

Dieser Satz ist kein Slogan.

Er beschreibt, wie Indrayala gebaut ist.

Lokal statt plattformzentriert.
Nachvollziehbar statt verborgen.
Menschengeführt statt autonom.

New Indrayala README.MD

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.