Solo.io

Gives organizations visibility and centralized governance over desktop AI tools while supporting consistent policy, identity, and activity monitoring.

Connects and governs LLMs, agents, tools, and models through one gateway, helping teams manage security, usage, performance, and visibility.

Helps teams reuse and deploy approved AI artifacts faster while giving operators visibility and governance across environments.

Connects and secures microservices and agentic workloads across distributed environments while providing service discovery, observability, and operational control.

Get expert help, security maintenance, and enterprise support to bring Istio deployments to production and operate them with confidence.

Run agents built with different frameworks on Kubernetes with unified identity, governance, observability, tool management, and human approval controls.

Manage and secure API traffic while enabling teams to build, deploy, and scale services with greater control and resilience.

Helps teams identify and respond to attack paths and threats from AI agents without changing their existing services.

Evaluate agent workflows from traces to understand output quality and gain continuous, framework-agnostic visibility into production behavior.

Infrastructure for platform teams to secure, connect, observe, and control service-to-service communication across clusters, clouds, and application runtimes.

Products: Istio, Istio Support

Capabilities for API gateway, lifecycle governance, publication, cataloging and developer onboarding to expose, secure and govern APIs across environments.

Products: Kgateway

Infrastructure for enterprise teams to centralize access to models, agents, and MCP servers, enforce traffic policies, control consumption, and observe AI interactions.

Products: agentgateway

Platforms that deploy, coordinate, govern, and observe multi-agent AI workflows—providing orchestration, model governance, connectors, developer SDKs, and observability for automated business processes.

Products: kagent

Controls that secure agent execution and access to tools, data, and models through workload isolation, identity enforcement, access policies, provenance verification, and auditing.

Products: Agentdesktop, Agentregistry, agentshield, agentgateway, kagent

Agentdesktop

Agentdesktop is an open-source governance layer for AI tools and agents running on desktop fleets. It provides real-time inventory, centrally managed configuration, non-human identity with short-lived credentials, and opt-in observability. Teams can use standalone mode for a single desktop or fleet mode with an endpoint daemon and central controller. Licensed under Apache 2.0, it integrates with an organization's existing identity provider, PKI, and LLM gateway.

• Issue Short-Lived, Least-Privilege Credentials
  Provides verifiable, identity-bound credentials for agents and avoids the blast radius associated with long-lived secrets stored locally.
• Discover AI Tools Across The Fleet
  Shows teams what AI tools and components are running and where, helping them identify activity across desktop devices.
• Apply And Reconcile Fleet-Wide Configuration
  Helps organizations maintain a consistent security posture by distributing centrally managed configuration to harnesses and continuously addressing drift.
• Monitor Selected Agent Activity
  Gives administrators awareness of agent activity while allowing them to choose which session and tool-use events are collected.
• Govern One Desktop Or An Entire Fleet
  Lets teams start with local governance on one desktop and extend management across a fleet using MDM and a central controller.
• Audit And Extend Existing Integrations
  Enables organizations to review collection behavior and identity boundaries, extend integrations, and continue using existing infrastructure.

agentgateway

Agentgateway is an open-source, Rust-built gateway for AI and agentic traffic. It provides a unified data plane for LLM providers, MCP servers, agents, and self-hosted models, supporting MCP and A2A protocols. It helps teams manage traffic, apply identity and access policies, control usage and costs, and observe interactions across LLM, agent, and tool calls. Its inference gateway routes requests to self-hosted models using context and capacity signals. Enterprise capabilities include centralized key management, guardrails, audit trails, and management across Kubernetes or other infrastructure, with standalone deployment and UI management.

• Trace Model Usage And Agent Interactions
  Gateway traces and metrics provide visibility into requests, token consumption, model usage, and activity across agent, tool, and backend call chains.
• Enforce Identity And Tool Access
  Identity and authorization capabilities help control which agents and users can access tools and services.
• Validate And Sandbox MCP Access
  Centralized validation, sandboxing, and policies help teams inspect requested backend URLs and govern access to MCP servers and tools.
• Connect Agents And Tools Securely
  MCP and A2A support provides a common gateway for agent-to-tool and agent-to-agent traffic, including cross-boundary connectivity and capability discovery.
• Handle AI Traffic With Low Overhead
  The Rust-based design supports high-throughput, low-latency handling of agentic traffic.
• Access Multiple Models Through One API
  A unified interface lets applications connect to multiple model providers and self-hosted models without code changes when switching models.
• Block Prompt Attacks And Data Leaks
  Inline checks and custom semantic rules help inspect prompts and responses and prevent specified threats or sensitive data exposure.
• Centralize And Protect Provider Keys
  Centralized storage and access controls let teams manage provider credentials through the gateway rather than distributing keys across teams.
• Control Usage And Limit Spend
  Rate limits, quotas, and budget enforcement help teams govern AI consumption and avoid unexpected usage costs.
• Route Requests To The Right Model
  Context-aware routing and capacity signals direct requests to suitable self-hosted models, while scheduling and GPU-aware placement help manage inference workloads.
• Expose REST APIs As MCP Tools
  Teams can configure an OpenAPI specification to make API operations available as MCP tools without changing application code.
• Audit Agent And Tool Interactions
  Recorded tool calls and agent interactions support compliance reviews, debugging, and incident response.
• Deploy And Manage Across Environments
  Deploy the enterprise gateway on Kubernetes or other infrastructure, including standalone deployment, and manage it through a UI.
• Use An Open Vendor-Neutral Gateway
  Its Apache 2.0 license and vendor-neutral positioning provide an open-source option for agentic connectivity.

Agentregistry

Agentregistry is an open-source registry and unified control plane for packaging, curating, discovering, and deploying AI artifacts, including agents, MCP servers, skills, prompts, plugins, and models. Its centralized catalog supports semantic search, versioning, blueprints, prompt management, and multiple frameworks. Teams can import, score, validate, and approve artifacts before publishing them through a governed workflow. Discovery and deployment capabilities provide visibility across environments and support Kubernetes, cloud platforms, and local development environments. Runtime governance includes access policies, role-based access control, centralized observability, context optimization, and health monitoring.

• Find And Reuse Approved AI Artifacts
  Give teams a centralized place to discover and reuse AI artifacts, while scoring, validation, versioning, and approval workflows support trusted reuse.
• Discover AI Assets Across Environments
  Give organizations a consolidated view of their agent landscape, including artifact status, deployments, and inventory that may otherwise remain outside central visibility.
• Deploy Approved Artifacts Across Platforms
  Enable developers to move approved artifacts into their chosen environments while maintaining centralized oversight.
• Govern Agent Access And Actions
  Help platform teams apply access policies and runtime controls so agents operate within defined boundaries across environments.
• Monitor Agent Activity And Health
  Give platform teams visibility into runtime health and context-aware traces of interactions among tools, agents, and LLMs.
• Track Artifact History And Approvals
  Provide a record of artifact versions, approvals, creators, and deployment locations to support governance and compliance inquiries.
• Manage The Agent Lifecycle
  Support agent development, integration, and operation across distributed environments.

Istio

Istio is an open-source service mesh platform for connecting, securing, and observing communication between microservices without application code changes. Solo.io offers production-grade Istio and Solo Enterprise for Istio, extending Ambient Mesh across clusters, clouds, and non-Kubernetes runtimes. Capabilities include sidecar and sidecarless ambient deployments, multi-cluster connectivity, global service discovery, traffic policies, workload identity, egress controls, observability, mesh segmentation, runtime extensions, and agentgateway integration for governing AI traffic. Enterprise support options include managed certificate rotation and production support.

• Adopt Mesh Security Without Sidecars
  Manage service communication without deploying a sidecar alongside each application workload, with a supported migration path to ambient mesh.
• Connect Services Across Clusters
  Enable communication between services in distributed, multi-cluster environments using gateway-routed mutual TLS or direct networking.
• Discover And Route To Global Services
  Use one service name across clusters and route traffic to a nearby healthy instance with locality-aware load balancing and failover.
• Encrypt Service Traffic Automatically
  Protect service-to-service connections with mesh-managed mTLS, reducing the need for applications to implement transport encryption themselves.
• Authorize Workloads By Identity
  Apply authorization policies using cryptographically established workload identities and identity attributes, including across clusters.
• Apply Layer 7 Traffic Policies
  Route and govern service traffic at Layer 7 through waypoint proxies, with options to extend waypoint behavior or use agentgateway for AI-aware traffic.
• Observe Service Traffic Across Clusters
  Review service communication, policies, mTLS status, HTTP metrics, traces, and service health across clusters.
• Govern AI And Agent Traffic Through The Mesh
  Use agentgateway within the mesh to route and govern LLM, MCP, and A2A traffic while retaining mesh identity and encryption controls.
• Control Outbound Workload Traffic
  Set identity-based rules for outbound connections and use Layer 7 controls for external AI-provider traffic.
• Isolate Teams Within One Mesh
  Give teams separate mesh domains while supporting cross-cluster discovery and shared platform services.
• Extend Mesh Controls Beyond Kubernetes
  Bring supported ECS, virtual machine, and Lambda workloads into a mesh with security, traffic management, and observability.
• Support Production Istio Deployments
  Choose support options for production troubleshooting, security maintenance, long-term support, onboarding, and service-level agreements.
• Manage Certificate Rotation
  Use managed certificate rotation as part of the enterprise mesh capabilities.
• Manage Mesh Configuration With GitOps
  Automate and centrally manage mesh configuration across distributed environments using GitOps workflows.
• Improve Service Traffic Resilience
  Configure circuit breaking, fault injection, outlier detection, and timeouts to manage service traffic behavior.

Istio Support

Solo.io provides enterprise support, management, and security for Istio deployments in production, from sidecars to Ambient. Support includes expert architectural guidance, troubleshooting, enterprise SLAs, and tier-dependent services such as onboarding, proactive health checks, security maintenance, configuration insights, and multi-cluster observability. Higher tiers also offer advanced mesh capabilities, including managed certificate rotation, routable global services, and runtime extensions.

• Resolve Production Issues Faster
  Get help with production problems through support with response targets defined by issue severity and subscription tier.
• Get Guidance From Istio Experts
  Work with Istio specialists for architectural guidance and troubleshooting as you prepare and operate production mesh deployments.
• Maintain Istio Security
  Access security scanning, selected-version long-term support, and FIPS-certified builds according to subscription features.
• Choose Support Response Targets
  Select a support subscription with response targets suited to issue severity and operational needs.
• Accelerate Mesh Onboarding
  Use onboarding assistance and proactive health checks, where included in the selected tier, to support deployment and ongoing operations.
• Extend Istio Mesh Capabilities
  Add enterprise mesh capabilities through eligible subscriptions, including certificate management, multi-cluster services, Layer 7 visibility, and additional runtime environments.
• Monitor Mesh Configuration
  Use tier-dependent monitoring and insights to review Istio configuration and mesh health.
• Observe Meshes Across Clusters
  View mesh observability across multiple clusters using the monitoring capabilities available with the selected support tier.

kagent

kagent is an open-source, Kubernetes-native agent runtime and framework for DevOps and platform engineers. It extends Kubernetes with identity, orchestration, and governance capabilities for running AI agents in production. Teams can bring agents built with LangChain, CrewAI, Google ADK, A2A, or custom frameworks, and manage agent actions, tracing, approval workflows, and MCP tools. kagent also offers prebuilt agents and tools, with enterprise capabilities for governing agents and their workloads.

• Run AI Agents On Kubernetes
  Run and manage agent workloads within Kubernetes environments using a cloud-native runtime.
• Govern Agent Actions With Identity-Based Policies
  Give agents verifiable identities and apply granular access controls to their actions, including actions performed on behalf of users.
• Run Agents Built With Different Frameworks
  Bring agents built with supported frameworks into kagent and manage them through unified governance.
• Trace Agent Actions And Tool Calls
  Follow agent actions, tool calls, and decision paths through tracing and visualization with OpenTelemetry.
• Require Human Approval For Critical Decisions
  Keep people involved in critical decisions by defining approval workflows, review checkpoints, and escalation paths.
• Deploy And Manage MCP Tool Servers
  Manage MCP tool servers through deployment, security, sandboxing, and lifecycle controls.
• Manage Agent Lifecycles Across Environments
  Support agent development, integration, and operation across Kubernetes and distributed environments.
• Start With Production-Ready Agents And Tools
  Use prebuilt agents and MCP-enabled tools, including options for Kubernetes management and observability.
• Manage Agents Through Kubernetes And GitOps
  Use declarative Kubernetes resources and GitOps workflows to manage agents through established platform operations.
• Run Agents With Substrate Runtime Support
  Use Agent Substrate with kagent for actor lifecycle controls, traffic routing, and sandboxed execution.

Kgateway

Kgateway is a Kubernetes-native ingress controller and API gateway built on Envoy and the Kubernetes Gateway API. Its open-source edition provides API traffic management, security, and resilience, while Solo Enterprise adds a developer portal, analytics, advanced security controls, multi-cluster routing, and enterprise support. It supports REST, gRPC, GraphQL, WebSocket, and other traffic, with self-service route delegation for application teams. Enterprise capabilities include staged transformations, AWS Lambda integration, Istio ambient connectivity, API self-service and usage analytics, and GitOps compatibility. It can be self-managed in customers' own cloud environments.

• Route Requests Across API Protocols
  Apply Kubernetes-native routing rules across protocols and request attributes through centralized gateway configuration.
• Adopt An Open-Source Gateway
  Use an Apache 2.0-licensed, Kubernetes-native gateway with enterprise extensions available when needed.
• Handle High-Volume API Traffic
  Run a gateway designed for high-volume traffic in customer-managed cloud environments.
• Delegate Routing To Application Teams
  Give application teams ownership of route configuration while supporting inherited platform policies.
• Authenticate Connections With Mutual TLS
  Use mutual TLS to secure communications between clients, gateways, upstreams, and services.
• Integrate Authentication And Enforce Policies
  Connect custom authentication services, enforce OPA policies, and manage API keys at the gateway.
• Filter Harmful HTTP Traffic
  Apply ModSecurity rules and the OWASP Core Rule Set to monitor, filter, and block harmful HTTP traffic.
• Mask Sensitive Data In Gateway Outputs
  Mask sensitive information in responses, headers, and logs to help prevent exposure.
• Get Enterprise Support And Version Maintenance
  Receive support with guaranteed response times, extended version maintenance, security patches, bug fixes, and direct access to Solo.io engineers.
• Control Progressive Traffic Rollouts
  Direct configured proportions of traffic to destinations to support canary deployments, A/B testing, and progressive releases.
• Transform Complex Requests And Responses
  Use templating to extract, inject, and modify payloads as part of staged transformations.
• Route Traffic Across Clusters
  Integrate gateway ingress with Istio ambient services and route across clusters with service-level failover.
• Secure API Connections With TLS
  Terminate TLS at the edge, manage certificates automatically, and route requests based on SNI.
• Validate JWTs At The Gateway
  Check JWT tokens at the gateway and use extracted claims in routing and authorization decisions.
• Deploy FIPS-Compliant Gateway Images
  Use hardened images that meet FIPS standards for regulated environments.
• Improve Service Traffic Resilience
  Configure retries and timeouts, and detect and eject outlier endpoints to help prevent failures from cascading.
• Apply Local And Distributed Rate Limits
  Control request volumes at individual gateways or across replicas using configurable attributes.
• Help Developers Discover And Access APIs
  Provide a customizable place to discover APIs, review API products, provision credentials, and request access.
• Modify Headers And Rewrite URLs
  Control request and response headers, adapt URL components, and redirect HTTP requests to HTTPS.
• Connect APIs To AWS Lambda
  Route API traffic to AWS Lambda with automatic request and response translation.
• Check Backend Health Automatically
  Identify unhealthy endpoints, remove them from service, and restore them when they recover.
• Track API Usage And Set Product Limits
  Review API usage and errors, and define rate limits and access controls for API products.
• Integrate With Existing Delivery Pipelines
  Use the gateway with existing GitOps and progressive delivery pipelines for infrastructure and applications.
• Apply CORS Policies And Validate CSRF Tokens
  Configure cross-origin resource sharing policies and validate CSRF tokens at the gateway.
• Test Changes With Mirrored Traffic
  Send shadow traffic to test new versions or debug production issues while preserving the normal traffic destination.

agentshield

agentshield is an open-source protection layer for existing infrastructure, defending data, APIs, services, and workloads against AI agents an organization does not control. It addresses attacker agents, external agents that misbehave, and an organization's own agents when they escape a sandbox or evade guardrails. The project maps potential attack paths, detects threats, and provides remediation recommendations. Its plugins instrument infrastructure from platform to kernel without requiring changes to services. Findings can be reviewed and remediated by human operators or passed to an agent for remediation; infrastructure changes are not made automatically.

• Map Reachable Systems And Attack Paths
  See potential routes for lateral movement and understand which systems and resources may be reachable.
• Instrument Infrastructure Without Changing Services
  Gain instrumentation across infrastructure layers while leaving existing services unchanged.
• Generate And Evaluate Rules Continuously
  Generate rules in response to changes in the attack-path graph and evaluate them continuously at runtime.
• Prioritize Findings With Remediation Steps
  Review findings with severity, affected systems, evidence, and remediation guidance.
• Remediate Findings With Human Oversight
  Use remediation advice or give findings to an agent for automated remediation while keeping infrastructure changes subject to human approval.

agentevals

Agentevals is an open-source tool for evaluating AI agent workflows. It uses traces from agent runs to assess performance and provides a Web UI EvalSet Builder to create evaluation sets from existing traces. Teams can run benchmarks and tests against traces, with evaluation and quality signals captured using OpenTelemetry rather than in-process instrumentation.

• Assess Agent Workflow Quality
  Grade agent traces to understand how well workflows performed and review results for a particular workflow.
• Build Reusable Evaluation Sets
  Turn existing agent traces into EvalSets that can be used to run benchmarks and tests.
• Capture Agent Quality Signals
  Capture evaluation and quality signals through OpenTelemetry without relying on in-process instrumentation.
• Monitor Agents Across Frameworks
  Gain visibility into production agent behavior across frameworks and throughout the agentic loop.
• Evaluate JSON Agent Traces
  Load agent traces from JSON files, including the documented Jaeger JSON format, for evaluation.
• Run Evaluations From The CLI
  Install the CLI using the Python package or from source, then run evaluations against trace files.