The Snake Is Moving Up the Stack

Anaconda has acquired Enkrypt AI, a company focused on finding and mitigating security, safety and compliance risks in enterprise AI systems. On its own, that would be another notable deal in an increasingly busy AI security market. Viewed alongside Anaconda’s other recent acquisitions, however, it reveals something considerably more ambitious.

Anaconda is not simply adding security features to its Python distribution. It is assembling the components of an enterprise AI platform.

In April, Anaconda acquired Outerbounds, the company behind the Metaflow open source orchestration framework. In July, it bought Kilo Code, a model-agnostic agentic engineering platform that operates inside the development environments where builders work. Now Enkrypt AI adds model and agent red teaming, runtime guardrails, MCP security and compliance automation.

These do not look like three unrelated acquisitions. They look like the outline of a control plane stretching from a developer’s first prompt to an AI-native application operating in production.

Anaconda already occupies a privileged position at the foundation of enterprise AI development. It curates the Python packages, models, dependencies and environments used by millions of developers and data scientists. The company says it reaches more than 52 million users and 95% of the Fortune 500. That reach gives Anaconda an enormous installed base, but reach alone does not guarantee that it will own the most valuable part of the emerging AI stack.

Foundational technologies have a habit of becoming indispensable and then invisible. Everyone depends on them, but customers increasingly treat them as plumbing. Anaconda appears determined not to remain in the basement while other companies build and monetize the floors above it.

The snake is moving up the stack.

From Package Management to AI Platform Engineering

The progression is logical. Anaconda’s traditional strength is establishing trusted environments from known packages and dependencies. Outerbounds extends that foundation into the orchestration of AI and machine learning workflows. Kilo Code puts Anaconda into the agentic engineering environment where developers prompt, generate, review and modify code. Enkrypt introduces the controls needed to evaluate and constrain models, agents and MCP servers before and after deployment.

Put the pieces together and Anaconda can make a plausible claim that it is building a governed path across the AI-native software development lifecycle.

That is also why this story belongs in the platform engineering conversation. Enterprise AI cannot scale if every application team must independently decide which models are acceptable, which MCP servers can be trusted, what permissions an agent should receive, how prompts and retrieved data will be protected, what behavior must be tested and how compliance will be demonstrated.

Those responsibilities have to become shared platform capabilities.

The emerging enterprise AI platform will need to provide approved packages, models and tools; reproducible development environments; access to agentic engineering capabilities; workflow orchestration; deployment automation; observability; policy enforcement; security testing; runtime guardrails and an audit trail. Developers should be able to consume those capabilities through a paved road without becoming experts in every security framework or regulatory requirement that applies to the organization.

This is what platform engineering was supposed to do in the cloud-native era. It reduced the cognitive load placed on application teams by turning infrastructure, deployment, security and operational practices into reusable services. AI now introduces a new layer of complexity that cannot be solved by handing developers another collection of policy documents.

The paved road for AI must govern more than code.

Traditional software supply chain security asks what packages, libraries and dependencies an application contains. AI-native security must also ask which model the application invokes, what data it can retrieve, which tools an agent can call, what an MCP server exposes, what permissions the agent possesses and what actions it can take without human approval.

The attack surface no longer ends with what software contains. It includes what the system can perceive, decide and do.

Enkrypt AI fills that gap in Anaconda’s emerging platform story. Its capabilities include predeployment red teaming across more than 300 attack categories, runtime protections designed to prevent jailbreaks and sensitive data leakage, MCP scanning and gateway controls, and automated mapping of policies to frameworks such as the NIST AI Risk Management Framework and the EU AI Act.

The important question is not whether each of those capabilities belongs in an enterprise AI stack. It clearly does. The question is whether Anaconda can turn them into integrated platform services rather than another set of tools that enterprises must stitch together themselves.

“The thing that is defining Anaconda’s platform is that we start with the builder. That allows us to accelerate their goals, and we look at it as taking what is their idea and accelerating it into reality.”

The Control Plane May Matter More Than the Model

Most public attention remains fixed on the model providers. OpenAI, Anthropic, Google, Meta and a growing field of open-weight model developers compete over intelligence, performance, price and reach. But enterprises are unlikely to entrust their entire AI estates to one model or provider.

They will use different models for different jobs. They will combine commercial APIs with open-weight models. Some workloads will run in public clouds, some on data platforms and others inside private infrastructure. The model that is best suited to a particular task today may not be the best choice six months from now.

That makes model neutrality more than a feature. It could become the foundation of a powerful control point.

The durable enterprise position may belong to the platform that determines which models can be used, where they can run, what data they can access, which tools they can call, how their behavior is evaluated and what happens when they move outside policy. Models may increasingly become interchangeable components within a platform whose governance layer remains constant.

That is the opportunity Anaconda appears to be pursuing. It is not trying to build the frontier model that defeats OpenAI or Anthropic. It is trying to become the trusted environment in which enterprises use those models, along with hundreds of others.

This would also provide Anaconda with an escape from the indispensability trap. Python package distribution gave the company a foundational role in data science and machine learning, but foundations often become commoditized precisely because everyone assumes they will always be there. Moving into orchestration, agentic development and security allows Anaconda to turn its existing trust and distribution into a much broader enterprise relationship.

The strategy is especially interesting because it runs across several markets that vendors continue to treat separately. Developer tools, machine learning operations, agent security, software supply chain security, compliance automation and platform engineering are converging around the same enterprise AI workload.

Anaconda is betting that customers would rather govern that workload through one coherent platform than assemble it from a dozen disconnected products.

“Companies like Databricks and Snowflake are strategic partners and Anaconda is available in their marketplaces, including the hyperscalers. Encrypt provides AI guardrails for agents that can be built into as you go into production.”

Three Acquisitions Do Not Automatically Make a Platform

There is a substantial difference between acquiring the right pieces and integrating them into the right product.

Outerbounds, Kilo Code and Enkrypt AI arrived as distinct companies with their own technologies, users, development priorities and architectures. Anaconda completed these three acquisitions within a little more than three months. That is an impressive statement of intent, but it also creates an enormous integration challenge.

Technology companies routinely declare themselves platforms after adding several products to the same sales catalog. The result is often less a platform than a collection of logos connected by arrows in a presentation.

Anaconda’s announcements are careful in places about the distinction between what exists today and what it is building toward. The Kilo announcement, for example, says that connecting its agentic development experience to Anaconda’s governed packages, models and environments is a direction the company is pursuing, not a capability already available. Enkrypt AI remains available with no immediate changes to its existing products, plans or customer support.

There is nothing inherently wrong with that. Acquisitions require time to integrate. But enterprises evaluating Anaconda’s broader vision need to understand where the platform exists as an operational reality and where it remains a roadmap.

The test will be continuity.

Can an enterprise establish an approved environment using Anaconda, begin building through Kilo, orchestrate the resulting application through Outerbounds and carry the same identity, provenance, policy and security context into Enkrypt’s testing and runtime enforcement? Can the platform explain which model, package, data source, tool and MCP server contributed to an agent’s action? Can it enforce a policy consistently when teams change models or move workloads between clouds and private infrastructure?

If the answer is yes, Anaconda will have built something much more consequential than an expanded portfolio. If the answer is that each acquired product generates its own policies, evidence and dashboards, customers will still be performing much of the integration work themselves.

Who Owns the AI Paved Road?

Anaconda’s strategy raises another question that reaches beyond the company: Who inside the enterprise will own this new control plane?

Data science teams understand the models. Developers build the applications. Security teams define controls. Legal and compliance teams interpret regulatory obligations. Infrastructure teams operate the compute. Platform teams are expected to turn all of that into something developers can actually consume.

No single group can govern enterprise AI alone. Yet distributing responsibility among five or six organizations without a shared platform is an invitation to inconsistency, delay and gaps in accountability.

Platform engineering is the most logical place for those concerns to converge, provided we do not mistake platform ownership for centralized command and control. The objective should not be to make every AI experiment wait for approval from a committee. It should be to encode the organization’s requirements into automated controls and reusable services.

A developer choosing an approved model should not have to interpret the EU AI Act. An agent connecting to an MCP server should encounter predefined identity, permission and logging requirements. A team preparing to deploy an application should be able to invoke red teaming and policy validation through the same workflow it uses to build and release the application.

Good guardrails allow teams to move faster because the safe path is already available. Bad governance simply relocates the bottleneck.

This tension may determine whether enterprise AI platform engineering succeeds. Companies need control over systems capable of accessing sensitive data and taking real-world actions, but they cannot manage AI at machine speed through tickets, spreadsheets and quarterly reviews. Governance must become executable.

That is what makes the Enkrypt acquisition strategically important. Security cannot remain a gate placed at the end of an AI development process. By the time an autonomous agent is operating in production, connecting to tools and making decisions, the important architectural choices have already been made.

Trust has to travel with the application from the foundation upward.

Anaconda now owns many of the pieces required to make that possible: the packages and models, the environments, the agentic development surface, the orchestration layer and the security controls. It also begins with something newer competitors cannot easily acquire, which is more than a decade of familiarity and trust among Python developers and enterprise data teams.

Whether those assets become an integrated control plane remains unresolved. Anaconda must demonstrate that its acquisitions produce a continuous governed experience rather than a broader collection of products. It must preserve the open, model-neutral and cloud-agnostic posture that made these technologies attractive while building an enterprise platform capable of enforcing real controls.

The strategy is now visible. Anaconda is moving beyond the distribution of AI’s ingredients and toward governance of the systems built from them.

If it succeeds, the most important part of the enterprise AI stack may not be the model generating the answer. It may be the platform deciding whether that model, agent and answer can be trusted in the first place.