Core
The domain-agnostic platform layer that lets Nizaam engines cooperate safely.
- Nizaam Core is the shared runtime contract: engines can focus on their own domain while using consistent identity, execution context, capabilities, messages, artifacts, health, observability, retries, and idempotency.
- Its Control Plane is responsible for registration, membership, routing, lifecycle coordination, and engine-to-engine boundaries. It provides the infrastructure for cooperation without deciding what Islamic knowledge means.
- The separation is intentional: Quran, Hadith, Arabic, Fiqh, search, and graph semantics belong to specialist engines, not to the shared platform.
Core execution flow
Shared infrastructure surrounds domain engines instead of absorbing their meaning.
Caller
Submits a capability request or domain operation.
Control Plane
Resolves identity, capability, route, lifecycle, and execution context.
Specialist engine
Executes domain logic and returns typed results or artifacts.
Purpose
Create a stable foundation for a long-lived ecosystem of cooperating Rust services. Shared concerns should be implemented once, tested centrally, and reused by every engine.
Architecture
Callers and specialist engines communicate through typed contracts and a controlled runtime boundary. Core owns identity, lifecycle, transport, and operational guarantees; each engine owns its domain model.
How it works
An engine registers with the Control Plane, receives an execution context, advertises capabilities, and exchanges structured messages. Health, retries, routing, and idempotency remain visible operational concepts rather than hidden side effects.
- Typed engine and instance identity
- Capability-aware routing and lifecycle
- Explicit artifacts, events, health, and recovery
Design decisions
Keep the core domain-agnostic, make boundaries explicit, and prefer evidence-driven evolution through unit and integration coverage. This lets specialist engines change without destabilizing the platform.