Glossary

Agent-to-Agent protocol. Used on the wire between agents within the Agent Runtime, and between external systems and the Agent Gateway.

Application-to-agent UI protocol. Used by Apps to reach the Agent Gateway.

Kubernetes custom resource that declares a single agent workload. Reconciled by the Agent Runtime Operator into a Deployment and Service.

Separate building block in front of the Agent Runtime. Translates external protocols (OpenAI Chat Completion API, A2A, AG-UI) into the internal A2A surface used by agents and routes requests to the appropriate agent. Defined by the AgentGateway and AgentGatewayClass CRDs.

Kubernetes-native execution environment that hosts agents and manages their lifecycle. Reconciled by the Agent Runtime Operator, which groups the Agent, AgenticWorkforce, and AgentRuntimeConfiguration CRDs and supports both template-based and custom-image agents on any framework that speaks A2A.

The agent-gateway resource (an instance) and its pluggable class (selects an implementation). Together they define an Agent Gateway deployment.

Namespace-scoped, operator-wide runtime configuration for the Agent Runtime. One instance per operator namespace; carries defaults such as the default framework and template images.

Platform layer containing the building blocks for AI agent orchestration: Agent Runtime, Agent Gateway, AI Gateway, Tool Gateway, Tool Servers, Guardrails, and Observability. Built on Kubernetes.

Application-level implementations of AI agent systems for specific enterprise use cases, such as Insurance Claims Processing, Healthcare Operations, or Procurement workflows.

Kubernetes custom resource that declares a named group of entry-point agents that collaborate to handle a workflow. The operator crawls each entry point’s sub-agent graph and records the transitive agents and tools in status.

Model facade and provider abstraction in front of Large Language Model providers. Routes LLM requests, manages credentials, and exposes telemetry. Defined by the AiGateway and AiGatewayClass CRDs.

Content inspection and policy enforcement for traffic flowing through gateways. Defined by the Guard and GuardrailProvider CRDs. Two implementation modes are supported: an adapter mode that delegates enforcement to an external service, and a native mode where the gateway implementation enforces the policy directly.

The AI gateway resource (an instance) and its pluggable class (selects an implementation). Note the lowercase i — the Go type is AiGateway.

Logging and tracking of AI operations, decisions, and interactions for regulatory compliance, security monitoring, and operational transparency.

Deployment model that lets organizations run the Agentic Layer within their own cloud infrastructure, retaining control over data, security, and compliance.

Design approach based on containerization, microservices, dynamic orchestration, and declarative APIs. Built for cloud environments with Kubernetes as the foundation.

Management interface for real-time monitoring and reporting against regulatory requirements such as the EU AI Act and GDPR.

Integration components that connect the Agentic Layer to external systems, databases, APIs, and third-party services.

The Agentic Layer’s primary function as a management and orchestration system for AI-driven processes and autonomous agents within enterprise environments.

The *Class pluggability mechanism shared by AgentGatewayClass, AiGatewayClass, ToolGatewayClass, and GuardrailProvider. The class CRD names an implementation; the instance CRD references a class. This lets the contract live in the Agent Runtime Operator while implementations live in separate operator repositories.

Maintaining control and governance over data location, processing, and access within defined jurisdictional and organizational boundaries.

Kubernetes custom resource that binds a guardrail policy to a target — a gateway, an agent, or a tool server.

Kubernetes custom resource that names the implementation enforcing a `Guard’s policy.

Infrastructure layer providing container orchestration, scaling, resource management, and service discovery for all Agentic Layer components.

Architecture and components designed to use Kubernetes primitives, APIs, and operational patterns for deployment, scaling, and management.

AI models trained on text to understand and generate human-like text. Examples include GPT, Gemini, and Claude, accessed through the AI Gateway.

Model Context Protocol. Used between the Tool Gateway and Tool Servers, both internal and external.

Execution environment that supports agents built with different AI frameworks while providing consistent operational characteristics and management interfaces.

Operational interface for monitoring, metrics, distributed tracing, and system health information across the Agentic Layer.

Protocol used by External Frontends to reach the Agent Gateway.

Agent validation and evaluation environment. Connects through the Agent Gateway like any other client.

The tool gateway resource (an instance) and its pluggable class (selects an implementation). Together they define a Tool Gateway deployment.

Per-consumer routing for tool calls. Governs which tool servers a given consumer can reach through a Tool Gateway.

Registers an MCP server — in-cluster or external — as a tool source.

Dependency on a specific vendor’s proprietary technologies that makes switching to alternatives difficult or costly. The Agentic Layer’s open-source and agnostic design is intended to prevent vendor lock-in.