Introducing Orca - StreamNative’s Agent Engine is Now Available for Private Preview

Autonomous AI agents are moving from research labs to real-world production systems – but until now, the infrastructure to support them at enterprise scale has been lacking. Many teams have experimented with agent frameworks in notebooks or demos, only to hit walls in production due to fragmented data, brittle pipelines, and siloed agent processes. StreamNative’s answer to this challenge is Orca Agent Engine (formerly known as “StreamNative Agent Engine”), an event-driven runtime and agent infrastructure designed for always-on, real-time AI agents. Previously available in limited early access, Orca Agent Engine is now in Private Preview on StreamNative Cloud – ready for developers to bring their own AI agents and run them on a unified streaming backbone.

What is Orca Agent Engine?

Orca Agent Engine is not another agent framework or library – it’s a streaming-native infrastructure layer for deploying, coordinating, and scaling AI agents in production. Think of it as the “missing backbone” that takes you from a prototype agent in a notebook to production-grade autonomous services. Evolved from Apache Pulsar’s battle-tested serverless compute foundation (Pulsar Functions), the Engine enhances agents with the event-driven capability. You simply package your existing agent code – whether built with Google’s Agent Development Kit (ADK) or OpenAI’s agent APIs, or even plain Python – and deploy it. Once deployed, the agent automatically joins a shared event bus and registry, immediately tapping into live data streams, maintaining its own state, and emitting actions – all under the governance and observability of the platform.

In essence, Orca Agent Engine provides the always-on “nervous system” that modern AI agents need but traditional setups lack. Instead of isolated bots operating on stale snapshots of data, every agent connects to its own data stream that delivers fresh, millisecond-level context. This event bus serves as a real-time context layer and communication channel for agents, so they can react to new events instantly and even talk to each other through events. The Engine also gives agents a built-in memory: each agent can own a persistent, distributed state that’s continually updated with invocations, externalized as events, and available for recall or audit. No more “black-box” agents with hidden state – an agent’s observations and decisions become part of an event log that can be inspected and traced later, providing much-needed transparency.

Crucially, Orca Agent Engine’s architecture is cloud-native, scalable, and resilient by design. Because it leverages a data streaming platform under the hood, agents benefit from horizontal scaling, load balancing, and fault tolerance out of the box. Agents run as distributed functions across a cluster – there’s no single choke point. If one instance goes down, the workload is seamlessly picked up by others, preventing any single agent failure from breaking your entire workflow. In short, the Engine handles the hard parts of running always-on, distributed agents – much like Kubernetes did for microservices, Orca provides that operational backbone for AI agents. You can focus on your agents’ logic and goals, while the platform takes care of real-time data plumbing, scaling, and reliability.

Key Capabilities and Features

Orca Agent Engine introduces a new paradigm for building real-time AI-driven applications. Here are some of its core capabilities in this Private Preview:

• Event-Driven, Streaming Runtime: Agents are always on, continuously listening to event streams and emitting new events as output. Rather than waiting for requests or periodic batches, agents subscribe to Apache Pulsar or Apache Kafka topics and react the moment events occur. This streaming-first design means your AI agents operate on up-to-the-second information – perfect for scenarios where data never sleeps. Agents can even trigger one another by publishing events, forming an asynchronous pipeline of decisions and actions driven entirely by data flows.
  
• Shared Event Bus (“Nervous System”): All agents – and other event producers/consumers – communicate over a unified event bus, eliminating silos. This bus acts as a shared context layer for your AI ecosystem. Agents no longer live in isolation or rely on polling for updates; instead, they receive a live feed of context (sensor readings, user actions, database changes, other agents' results/instructions, etc.) and can broadcast their own insights or alerts. The result is a network of agents that can collaborate in real time, share facts, and avoid redundant work. The event bus also provides built-in capabilities like message ordering, persistence, rate limiting control and replay (thanks to Pulsar’s log storage and the Kafka-compatible Ursa Engine), so agents can even “time-travel” or recover context as needed.
  
• Persistent Streaming Memory: Each agent can maintain stateful memory beyond a single prompt-response cycle. Backed by a distributed state store, an agent’s intermediate results or important observations are logged as events and stored for future reference. This means an agent can “remember” context over long conversations or continually learn from new data, without being limited by the stateless request/response pattern. Because the memory is externalized to the event stream, you gain full visibility into what the agent knows – every piece of state or decision rationale can be audited and replayed. This streaming memory model tackles one of the biggest challenges of agentic AI: making their decision-making process transparent and reproducible.
  
• Modular & Composable Agents: Orca encourages a decomposed approach to agent design, unlike monolithic chain-of-thought scripts. Complex tasks can be split into multiple specialized agents or functions that each handle a sub-task and communicate via events. For example, one “fast path” agent might apply quick rule-based decisions on incoming events, while a second “smart path” agent performs deeper LLM-powered analysis on the trickier cases – all orchestrated through the event bus. This modular design means your workflows are dynamic and data-driven: agents can decide at runtime to invoke different tools or even spawn other agents based on the situation. It also makes the system evolvable – you can add, remove, or update individual agents (much like microservices) without refactoring a giant codebase. In the Private Preview, you can experiment with building multi-agent systems where agents discover and call each other as needed, forming an “Agent Mesh” of collaborating services.
  
• Unified Registry and Tool Directory: Every agent deployed via Orca is registered in a central registry alongside other components like connectors and functions. This registry acts as a directory of all “brains” (agents) and available tools (services, functions, data connectors), along with their metadata. The benefit is twofold: (a) operators get a single control plane to manage and monitor all agents – you can see at a glance what agents are running, pause or update them, review their version and permissions, etc.; and (b) agents themselves can perform dynamic lookup of tools/peers. For instance, an orchestrator agent could query the registry to find a specific expert agent or function and then invoke it as a sub-task. This makes it much easier to build composed workflows where agents use other agents as tools. All of this is achieved without hard-coding integrations – the registry and event bus enable late-binding and discovery of capabilities at runtime.
  
• Bring Your Own Agent Framework: One of Orca’s biggest strengths is its framework-agnostic design. We know developers have already invested in popular AI agent frameworks and libraries – and we’re not reinventing yet another framework and asking you to abandon your existing agents. Instead, Orca lets you plug in the agents you’ve built with the tools you love. Whether your agent is powered by Google's Agent Development Kit (ADK) or OpenAI's  Agents SDK or just custom python code, it can run on the Orca Agent Engine without modification. (support for LangChain, LlamaIndex are also coming soon!). The Engine takes care of hosting your agent, connecting it to streams, managing its lifecycle, and scaling it out – no proprietary SDK or rewrite required. Different frameworks can even coexist: you might deploy one agent built with ADK and another with OpenAI’s framework, and they can communicate via the common event bus. This “bring-your-own-framework” approach future-proofs your architecture – you can adopt new agent libraries as they emerge, and Orca will support them as long as they can interface with a Python function. In the current Preview, Python-based agents are supported, with plans to extend to other runtimes as the ecosystem grows.
  
• Tools & External Integrations via MCP: In modern agent systems, functions are tools – and Orca makes it easy for agents to safely use tools through the emerging Model Context Protocol (MCP) standard. MCP (initially introduced by Anthropic) provides a uniform, secure way for AI agents to invoke external tools and access data. The Orca Engine embraces MCP so that your agents can call REST APIs, query databases, read from live data streams, invoke cloud services, or even manage infrastructure (like a Pulsar cluster) via natural language commands, all through a common interface. Under the hood, StreamNative’s own MCP Server (an open-source component) bridges your Pulsar/Kafka event streams with external tools and APIs, exposing them as on-demand functions that agents can discover. This means you don’t have to write custom glue code for each integration or worry about leaked credentials – define the tool once (with proper auth and schema) and any agent can use it when needed. With MCP and the unified registry, functions and even other agents become callable MCP tools. Orca Engine’s MCP integration also implements the complete MCP Client specification with dynamic tool discovery: any deployment change to an agent (added/updated/retired) is automatically propagated to other agents that subscribe to it as a tool, and the corresponding agent contexts refresh in near real time with updated capabilities and status. This drastically expands what your agents can do (e.g. fetch knowledge from a vector database, send an alert email, execute a workflow) while keeping the interactions governed and auditable.
  
• Enterprise-Grade Observability & Control: Running autonomous agents in production demands robust monitoring, security, and governance – and Orca is built with these needs in mind. Because agents communicate via standard event streams (Pulsar/Kafka) and log every action as events, you get a traceable audit log of every decision and tool invocation. Integration with StreamNative Cloud’s monitoring stack means you can trace event flows end-to-end, measure agent latencies, and catch anomalies. The unified registry and control plane let you enforce role-based access control (RBAC) for agents and tools, manage secrets securely, and roll out updates in a controlled way. Need to pause an agent’s autonomy in an emergency? You can disable its event subscriptions with a click. Want to debug why an agent made a certain decision? You can replay its event inputs or inspect its state log. In Private Preview, you’ll have access to searchable agent logs and basic tracing. These features give enterprises the confidence to deploy “agentic AI” with appropriate safeguards – ensuring that even as agents make decisions, humans stay in the loop with visibility and override capabilities.

Current Preview Availability and Getting Started

The Private Preview of Orca Agent Engine launches today on StreamNative Cloud, and we’re excited to open it up for more developers to explore. Initially, the Agent Engine is available on Bring-Your-Own-Cloud (BYOC) deployments of StreamNative Cloud (across AWS, GCP, and Azure), so you can run it in your own cloud environment with StreamNative managing the service. This ensures your data stays within your control while you experiment with real-time agents. Support for dedicated cloud clusters and other deployment modes is on the roadmap as we gather feedback in this preview phase.

At this stage of Private Preview, our focus is on core functionality and stability. The Engine supports Python-based agents and integrates seamlessly with Pulsar and Kafka streams (so you can feed it data from either platform). Key capabilities like the event bus, agent registry, persistent memory/context, and MCP tool connectivity are ready for use. We encourage you to try out the current capabilities and share your feedback with us. Your input will shape the roadmap toward GA (General Availability), including support for additional languages, deeper tooling, and more out-of-the-box agent patterns.

Try Orca Agent Engine Today

With Orca Agent Engine now in Private Preview, you can start turning your AI models and scripts into fully operational, event-driven services. Imagine an agent that monitors streaming customer support tickets and autonomously answers common issues, or a swarm of agents that detect anomalies in IoT sensor data and proactively coordinate responses – the possibilities are vast when you combine continuous streams with autonomous reasoning. We believe this decomposable, streaming-native approach will unlock a new class of intelligent applications that are reactive, context-aware, and scalable by design.

Ready to get started? Sign up for the Private Preview through StreamNative Cloud (contact us via the StreamNative Console or your account team to enable the Orca Agent Engine preview on your cluster). Our documentation and quickstart guides will help you deploy your first agent in minutes. Point your agent to a live topic, deploy it via our CLI or console, and watch as it comes alive in the stream – processing events in real time. Because Orca Agent Engine is framework-agnostic, you can bring an existing agent (for example, an OpenAI agent you’ve already built) and see it immediately operate on live data streams. No more fake stub data or offline demos – your agent becomes a continuous online service.

We are incredibly excited to see what you build with Orca. This Private Preview is just the beginning, and we’ll be rapidly iterating on the Engine with new features and improvements. Our goal is to empower developers to easily create real-time, autonomous AI systems that can perceive, reason, and act on data as it flows. With a streaming backbone uniting your agents workflows and tools, the limitations of static prompts and isolated bots melt away. Welcome to the era of streaming agents on StreamNative Cloud – where your AI agents can truly live in the stream, today.

Join the preview, give Orca Agent Engine a try, and let us know your feedback. Together, let’s shape the future of event-driven AI!