Skip to content
The State of Exposed AgentsRead the report
Guard0

Building Agents at Scale: Enterprise Lessons from LinkedIn, Salesforce, and Microsoft

How the world's largest companies are architecting AI agent systems, and the security gaps their approaches create.

· Updated · 12 min read · Guard0 Team

Building Agents at Scale: Enterprise Lessons from LinkedIn, Salesforce, and Microsoft

LinkedIn, Salesforce, Microsoft and many smaller organizations now run AI agents in production.

Gartner predicted in August 2025 that up to 40% of enterprise applications would include task-specific AI agents by 2026, up from less than 5% in 2025. Spending follows: the cost is not only model inference, but the orchestration layers, tool integrations and monitoring that agents need.

What follows looks at how some of the largest deployments are built, and the security questions their designs share.

* * *

LinkedIn: Messaging Infrastructure as Agent Substrate

LinkedIn has described its multi-agent platform in an engineering post, and InfoQ covered it. The notable decision: LinkedIn did not build a new agent communication layer. It extended the messaging infrastructure it already ran.

The member-to-member messaging system already handled bidirectional communication at scale, and the team understood how it failed. When agents needed to talk to each other, starting with the Hiring Assistant, that system was the foundation.

On top of it sits a skill registry. Agents are defined as gRPC services, annotated with metadata that describes what they do, and registered centrally. Applications use the registry both to discover a skill and to invoke it, so agent pipelines can be composed without hardcoded dependencies between agents. A central agent lifecycle service translates between messaging and RPC.

From an engineering perspective, this is a sensible design. It reuses existing investments and gets the composability multi-agent workflows need.

From a security perspective, it raises a point that applies to every multi-agent system: every agent-to-agent communication channel is a potential lateral movement path.

When agents communicate over a messaging substrate, the trust model of that substrate determines what an attacker can accomplish if they compromise a single agent. In a messaging system designed for human users, the trust assumptions are different: humans authenticate explicitly, have bounded permissions, and do not chain operations on their own. Agents do chain operations, and if the communication channel between them carries implicit trust, a compromised agent can potentially instruct other agents to act on its behalf.

Any skill registry is also a discovery surface. An attacker who gains read access to one learns what each agent can do and what interfaces it exposes. That is useful information for planning an attack.

None of this is specific to LinkedIn, and none of it is a claim about a flaw in LinkedIn's system. It applies to any multi-agent architecture built on existing communication infrastructure. Reusing infrastructure also reuses its security assumptions, and those need to be re-examined for agents.

* * *

Salesforce AgentForce: When Scale Forces Maturity

Salesforce launched AgentForce in late 2024 and has shipped several major versions since. Each one added more control over what an agent may do.

The pieces that matter for security are platform features, not per-customer configuration. Topics define which subjects an agent is allowed to discuss and act on. The Einstein Trust Layer handles grounding, data masking and audit logging. Agents run with a defined user context and permission set.

The reason these controls matter grows with scale. When an organization has one or two agents, a careful engineer can keep the security model in their head. When there are hundreds, an agent that inherits a broad permission set and acts autonomously turns one misconfiguration into a large incident, and audit questions about what the agent did get harder to answer. At that point you need systematic governance.

Most enterprises are reaching this point now, across every agent platform. Teams that deployed agents to see what was possible are now running them in production, where operational discipline is required.

For a detailed breakdown of AgentForce's security model and how to configure it correctly, see our Salesforce AgentForce Security Guide.

* * *

Microsoft Copilot: From Helpers to Workers

Microsoft's path with Copilot shows a shift that is happening across the industry.

The original Copilot framing was about assistance. Copilot would help you draft an email, summarize a document, or suggest the next action. The human remained in the loop for every meaningful decision.

That framing has changed. Copilot Studio supports autonomous agents: workflows that run without human approval at each step and can call external APIs, trigger Power Automate flows, read from SharePoint, query Dynamics 365, and take actions across the Microsoft 365 ecosystem without a human reviewing each operation.

Copilot Studio now supports multi-agent orchestration, where one agent can invoke another, pass context between them, and compose complex workflows from simpler agent building blocks. Microsoft added Model Context Protocol (MCP) support to Copilot Studio in 2025, so Copilot agents can connect to MCP servers as well as the native Microsoft connectors.

The shift from helpers to workers changes the threat model.

A Copilot assistant that helps draft emails operates within a narrow scope: it reads context, generates text, waits for human approval. If it behaves unexpectedly, a human catches the error before it propagates. An autonomous Copilot agent that processes incoming contract requests, updates Dynamics 365 records, triggers approval workflows, and sends external communications operates within a much broader scope, and can propagate errors or malicious instructions across multiple systems before any human reviews the output.

Traditional controls assume humans are the actors. Access controls govern what a user can do. Audit logs record what a user did. Approval workflows require a human decision. When agents become the actors, those controls either need to be extended to cover agent identities explicitly, or they become gaps.

For detailed guidance on securing Copilot Studio deployments, see our Copilot Studio Security Guide.

* * *

OpenAI's Platform Play: Standardizing Agent Infrastructure

OpenAI is a different kind of player: its models already sit underneath a large share of enterprise AI deployments.

The Agents SDK, released in 2025, is a framework for building multi-agent systems on OpenAI models. It introduces handoffs, the mechanism by which one agent transfers control to another, and guardrails, which are programmable checks that run on agent inputs and outputs.

OpenAI also offers an enterprise platform for deploying and managing agents. What separates it from the standard API is the operational layer: logging, tracing, usage controls, and policy applied at the platform level instead of re-implemented in each agent.

OpenAI is a co-founder, with Anthropic and Block, of the Agentic AI Foundation, the Linux Foundation fund that now governs shared agent standards including MCP.

The direction is clear: OpenAI is moving from model provider to agent infrastructure provider. That changes the security considerations for enterprises that build on its platform.

* * *

MCP: The TCP/IP of the Agent Ecosystem

Model Context Protocol has done something rare in infrastructure: it was adopted quickly, across vendors, because it was useful.

In December 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation, making it a neutrally governed standard. Microsoft, OpenAI, Google and many tool providers have added MCP support to their platforms.

The analogy to TCP/IP holds in one specific way. TCP/IP didn't define what applications would be built on top of it; it defined the communication contract that allowed them to interoperate. MCP similarly defines how agents communicate with tools and data sources, without dictating what those tools do or how the agents are built. This neutrality is what drives adoption: any agent that speaks MCP can connect to any MCP server, regardless of vendor.

The practical consequence for enterprises is that MCP is becoming the default integration layer. When a new tool or data source supports MCP, it becomes accessible to every agent that supports MCP, automatically.

The security consequence follows from the same logic. If MCP is the universal connection layer, then MCP security is the universal attack surface. A misconfigured MCP server can expose every agent connected to it, on any platform.

MCP was designed for connectivity first. The specification defines an OAuth-based authorization flow for remote servers, but using it is up to whoever runs each server, and audit logging is left to the implementation. Our own census of public MCP servers reached 2,958 servers in July 2026, and 1,139 of them answered with no authentication.

Our MCP Security Guide covers the specific attack vectors and mitigation approaches in detail.

* * *

The Common Security Gap Across Enterprise Architectures

LinkedIn's gRPC skill registry, Salesforce's AgentForce topic framework, Microsoft's multi-agent orchestration, OpenAI's handoff mechanism, and MCP's universal tool integration layer are different implementations, built by different teams, with different design priorities. But they share a common set of security challenges.

COMMON SECURITY GAPS ACROSS ENTERPRISE AGENT PLATFORMS
No Agent Iden…Broad Permiss…No Multi-Agen…Shadow AgentsNo Audit Trail

No standardized agent identity framework. Agents act on behalf of organizations, systems, and users, but in many deployments they don't have formal identities that satisfy enterprise security requirements. They inherit the credentials of the users or service accounts that configured them. They are not enrolled in identity governance workflows. They are not subject to periodic access review. When a security team asks "who is this agent, what can it access, and who authorized it," the answer is often unclear.

This is not a criticism of any one platform. It reflects the pace of the market. Identity standards for non-human actors are still being developed. But the absence of a standardized framework means each organization must solve the identity problem independently, or leave it unsolved. See our analysis of AI Agent Identity for a deeper treatment.

Tool permissions are often too broad. Agents are commonly granted more permissions than their job requires. The reasons are practical: narrowly scoped permissions require careful upfront configuration, and most teams are prioritizing time-to-deployment. The result is agents with read/write access to data they never need to read or write, and with the ability to call APIs whose outputs they never process.

Broad permissions are more than a compliance concern. They are how a compromised or misbehaving agent can escalate the impact of an incident.

Multi-agent communication lacks built-in authentication. When Agent A invokes Agent B, passing instructions and context, many implementations do not cryptographically verify that the invocation is authorized. The receiving agent trusts the message because it arrived on the expected channel. This creates the conditions for agent impersonation: an attacker who can inject a message into the channel can instruct agents to take actions they were never authorized to perform.

Shadow agents proliferate in parallel with official deployments. Alongside sanctioned agent deployments there are usually unsanctioned ones in the same environment: teams standing up agents to test an idea, individual contributors building integrations with personal API keys, pilot programs that were never officially shut down. These shadow agents are not subject to the controls applied to official deployments, often run with elevated permissions, and do not appear in monitoring.

As the number of official agents grows, so does the number of unofficial ones, because deploying unofficially is easier. See our coverage of Shadow Agents for discovery strategies.

* * *
Secure Agent Lifecycle
⚙Develop🔍Assess🚀Deploy📡Monitor🔄Update

What This Means for Enterprise Security Teams

The analysis above is not an argument against building agents at scale. The argument is that agent security has to keep pace with agent capability, and right now it does not.

There is a useful frame for thinking about where enterprise agent programs typically are:

Maturity StageCharacteristicSecurity Posture
ExperimentationAd-hoc deployments, small teams, limited scopeFew agents, easy to monitor by hand
ExpansionDozens to hundreds of agents, multiple platforms, cross-team adoptionSecurity debt accumulating: controls don't scale with deployment speed
Production ScaleHundreds to thousands of agents, embedded in critical workflowsThe security gap is a business risk and needs a systematic approach

Most enterprises reading this are somewhere between expansion and production scale.

Three capabilities define what systematic agent security looks like at this stage:

Discover: You cannot govern what you cannot see. The first priority is continuous discovery of every agent running in your environment: the ones in the official registry, and also the experiments, the shadow deployments, and the integrations built by individual teams. This requires monitoring at the infrastructure level, not just the application level.

Assess: Once you know what is running, you need to understand the risk each agent carries: what vulnerabilities exist, what data it can access, what actions it can take, and whether its configuration meets your governance and compliance requirements. Assessment must be continuous, not a one-time audit.

Record: Accountability requires evidence. Agent actions, tool calls and data access need to be logged, attributed to an agent and an owner, and available for audit. When a regulator asks what your agents did, when a customer asks how their data was handled, or when you need to reconstruct an incident, you need a record.

This is Guard0's thesis: agent accountability needs the same systematic, continuous approach that network security and endpoint security needed when those attack surfaces grew. Guard0 finds the agents in a company, maps what each one can reach, records a named owner for each, and tests how they behave. See the platform.

* * *
See Guard0 in action

Live walkthrough of agent discovery, risk scoring, and policy enforcement.

Book a Demo
*Key Takeaways
  • Enterprise AI agents have moved from experiments into production
  • The designs used by LinkedIn, Salesforce, Microsoft, and OpenAI each carry security assumptions that operators must understand
  • MCP has achieved cross-vendor adoption, making MCP security a universal concern for multi-platform deployments
  • Four gaps appear consistently: absent agent identity, overly broad permissions, unauthenticated multi-agent communication, and shadow agents
  • At scale the work is Discover, Assess, Record, applied continuously, not as a one-time audit
* * *

Next Steps

If your organization is in the expansion or production-scale phase of agent deployment, here is where to start:

Request a free AI risk assessment. Guard0 tests the agents, MCP servers and AI applications you already run and sends you the findings. Request an assessment.

Talk to the Guard0 team if you are working through a specific architecture or preparing a board conversation about agent risk. Book a demo.

Start free

Enterprise AI · AI Agents · Architecture · Market Intelligence · Agentic AI

Guard0 Team