Reference Applications
Examples built with K9-AIF
Practical demos showing how K9-AIF structures routing, orchestration, squads, agents,
model abstraction, governance, and domain workflows in real AI applications.
These examples show how the K9-AIF Framework can be applied to practical,
domain-oriented AI systems while preserving architectural structure, modularity, and governance.
Together, they demonstrate how K9-AIF uses stable Architecture Building Blocks (ABB)
to host configurable Solution Building Blocks (SBB), including routing,
orchestration, squads, agent behaviors, intelligent model selection, and domain workflows.
The EOC is the K9-AIF equivalent of the J2EE PetStore — a comprehensive,
end-to-end reference application that demonstrates every major capability of the framework
working together in a realistic enterprise domain. If you want to understand what a
complete K9-AIF application looks like, start here.
A production-grade, runnable multi-agent application built on the K9-AIF Framework.
The EOC models a realistic enterprise insurance operations domain end-to-end — from event ingestion
to governed agent execution to immutable audit trails.
Generated using Claude Code from a project spec document, demonstrating
how K9-AIF's architecture-first approach enables consistent, governed application generation.
- Kafka-driven event routing —
eoc-events fan-out to domain topics
- Router → Orchestrator → Squad → Agent full execution hierarchy
- Intelligent Model Router — weighted scoring across capability, latency, cost, and sensitivity signals
- Zero Trust execution — governance enforced at every agent boundary
- PII inspection, fraud detection, adjudication, and policy compliance agents
- HITL escalation — human-in-the-loop queue with real-time Web UI
- Immutable audit trails and Neo4j graph synchronization
- Deployed as a 3-container Podman pod on RHEL with PostgreSQL persistence
- Fully YAML-driven — routing rules, governance policies, squad flows, model assignments
An enterprise-style support workflow example built on the K9-AIF Framework.
Demonstrates how K9-AIF structures a customer-facing support system using specialized agents,
configurable reasoning behaviors, and stable framework architecture.
- Router → Orchestrator → Squad → Agent execution flow
- ModelRouterFactory usage for inference abstraction
- Configurable reasoning patterns — ReAct, Agentic RAG, Plan & Execute, Reflection, and multi-agent collaboration
- Clear separation between ABB and SBB
- Squad-based specialization across support roles
- Runtime logging and observability through K9-AIF framework hooks
A lightweight browser-based chat example built on the K9-AIF Framework.
A clean starting point for understanding how K9-AIF separates agent logic, routing,
inference configuration, persistence, and UI integration.
- Squad + Agent execution pattern
- ModelRouterFactory usage for inference abstraction
- Default K9ModelRouter routing behavior
- Integration with configurable LLM providers such as Ollama
- Default SQLite-backed router state persistence
- Browser-based interaction with runtime metadata display
A domain-oriented example showing how K9-AIF supports structured, document-heavy,
workflow-driven enterprise scenarios — where architecture, modularity, and workflow
structure matter more than a single prompt-response interaction.
- Claims-related workflow structure
- Intake and document-processing patterns
- Domain-specific orchestration
- Extensible enterprise solution design aligned to real business processes
- Modular AI solution composition using K9-AIF concepts
Demonstrates the K9 Zero Trust Execution Layer — a vendor-neutral
runtime security pattern integrated into K9-AIF. Traditional Zero Trust focuses on
access. K9-AIF extends it to execution: every agent action is verified before it runs.
- Runtime evaluation of identity, data sensitivity, destination, and contextual risk
- Execution control across Router → Orchestrator → Agents → Tools
- Policy-driven allow / conditional / deny decisions at agent boundaries
- Potential compromise signal detection and data loss risk evaluation
- Governance policies enforced declaratively — no hardcoded logic in agent code
A side-by-side architecture demonstration showing the same application built two ways:
as a pure CrewAI application, and as a K9-AIF governed version
of the same application. Illustrates what K9-AIF's architecture layer adds on top of
a CrewAI runtime.
- Side-by-side CrewAI vs K9-AIF implementation of identical functionality
- K9-AIF CrewAI adapter pattern — CrewAI as an orchestration SBB
- Governance, routing, and observability layered over an existing agent runtime
- Demonstrates K9-AIF as an architectural wrapper, not a replacement
How to run the examples
From the root of the k9-aif-framework repository, the included shell scripts can be
used to quickly launch selected examples.
./run_k9chat.sh
./run_acme_support_center.sh
For the EOC (RHEL / Podman deployment):
bash run_eoc_pod.sh
For deeper implementation details, class diagrams, and example-specific documentation,
use the links above to open the corresponding example folders in the repository.
These examples are intentionally practical. They are not intended to be full production products
out of the box, but to demonstrate how K9-AIF can be used as an
architecture-first framework for building modular, governed, and extensible AI applications.