K9X Streams turns your event streams into live, governed context that agents built on K9-AIF ask for over MCP: the current state of what they reason about, what just changed, and how fresh it is, checked by k9x Shield before an agent reads a word of it.
Not a document from last night: the value as it is now, how old it is, and the exact event that set it. Here a payment-release agent re-checks an invoice just before releasing it.
k9x Origin is built into the K9-AIF framework, like k9x Shield. An agent asks one question,
get_current(entity, id), and gets the current value, when it changed, where it came from, and any reason
not to trust it. K9X Streams is the reference demo you can run.
as_of, source,
version and flags. Whether a claim over $5,000 needs a person is a business rule, not Origin's call.version, so they are refused if anything changed.For solution architects: the configuration, the five steps and the class diagrams are on Architecture →
K9X Streams is how to build an agentic application that must act on the latest information. Copy the model, not the code: your sources and your projections change; the fabric, the governance and the way agents read live context stay the same.
KafkaEventFabricGovernanceEventGate · k9x Shield; refused → quarantinedlive_contextArchitecture → sources, the five steps, security controls, and the class diagrams for solution architects.
A K9-AIF solution already has agents, squads, orchestrators and governance. K9X Streams adds the one thing a snapshot can't give them: the world as it is right now, delivered the way the framework already handles tools.
get_current, recent_changes and query,
called with the framework's own MCP client (MCPStreamableHttpConnector). No new client code in your agents.
Every answer carries as_of, age_seconds and
version. Whether an age matters for a decision is a business rule, not something Origin decides.
Each value names the Kafka topic and offset of the event that set it, so a decision can be traced back to the exact record behind it.
Stream data is untrusted input. Every event passes k9x Shield at the gate
(GovernanceEventGate, with PromptInjectionCheck and PaymentDiversionCheck); a refused
event is quarantined, never applied. Each answer an agent reads is screened again (screen_tool_result).
The Orchestrator adds live_context for the entities a flow is
about before the squad runs; an agent that must re-check just before acting asks over MCP.
The live state replays from the topics on start, so Kafka stays the source of truth and a restart loses nothing.
A rule on a stream ("payment posted for an invoice under review") publishes a domain event, and the K9-AIF Router starts a squad, the same way events work today.
Agents never read Kafka directly. A model can't drink from a firehose; at decision time it needs the current state and what just changed.
ap.invoice.updated, ap.payment.posted, ap.vendor.flagged.as_of and the source event. Rebuilt from the topics on start.live_context; just before acting the agent re-checks over MCP.Accounts Payable on simulated data. A payment-release agent reviews an approved invoice for a few seconds, and in three of the four scenarios the world changes while it is reviewing.
Nothing changes. The agent re-checks the live state and releases.
Another system pays the invoice mid-review. Live state shows it, seconds old.
A sanctions flag for the vendor arrives on the stream mid-review.
A vendor note carries hidden instructions to pay a new account. Shield refuses it at the gate; the vendor is quarantined.
Open the live demo → Start the generator, then run a scenario and watch each event, each MCP call and the decision.
K9-AIF (Agentic Integration Framework) is an architecture-first framework for building governed, secure, and enterprise-scale AI applications. Built on OOA/OOD principles and TOGAF-aligned, it brings consistency, governance, and auditability to agentic systems from day one. Every Router, Orchestrator, Squad and Agent in an application built on K9-AIF extends a K9-AIF Architecture Building Block, so governance, human review and auditability are inherited, not hand-built per application.
Security checks that keep pace with new attacks. AI is now used to attack applications that are themselves built with AI: instructions hidden in documents, agents impersonating other agents, poisoned tool results. K9-AIF tracks these attack techniques as they are published and adds matching checks to the framework's governance pipeline. Solutions built on K9-AIF pick up the new checks with a framework upgrade, without rewriting their own agents. K9X Sentinel reads newly published attacks every day and checks each one against the framework's security capabilities.
The K9X ecosystem brings the framework to life: K9X HIL (the human decisions an agent can pause for), K9X Sentinel (above), K9X Satan (an adversarial harness that proves the defences hold), and now K9X Streams, the reference demo of k9x Origin (K9-AIF 1.18): one governed call for what is true right now, built into the framework like k9x Shield.
live_context and MCP tools.RequiresHIL) is the next step.