返回资讯中心
外部精选
软件工程
#开发者实时流

Salesforce Headless 360 MCP 服务器让 AI 代理以连接者身份操作组织

来源标题:What an Agent Can Reach Through the Headless 360 MCP Server

Salesforce 的 Headless 360 MCP 服务器允许 AI 代理以连接它的用户身份在组织内操作,该用户能访问的权限代理都能触及,多数组织中这远超其工作所需。代理的能力范围并非固定列表,而是在运行时查询并获得排序后的候选操作再调用。文章介绍了代理如何发现操作、为何无法在启用前确定集成范围,以及用户本身已具备的权限。

Hacker News 最新daretograsp2026/11/16 · 昨天30 分钟阅读

以下正文同步自 Hacker News 最新,版权归原站所有,已转换为易读排版。

Take a personalized product tour with a member of our team to see how we can help make your existing security teams and tools more effective within minutes.

First NameLast NameEmail AddressCompanyThank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

Home

Blog

What an Agent Can Reach Through the Headless 360 MCP Server

What an Agent Can Reach Through the Headless 360 MCP Server

Nitay Bachrach

Updated

November 12, 2026

November 12, 2026

8 min read

Ready to Close the SaaS Security Gap?

Chat with us

Salesforce's Headless 360 MCP server lets an AI agent act in your org as the person who connected it. Whatever that user can reach, the agent reaches, and in most orgs that is a great deal more than their job needs. The agent does not get a fixed list of what it can do either - it asks at runtime, gets back a ranked set of candidate operations, and calls one.

This post covers how an agent finds an operation, why you cannot write down what the integration reaches before you turn it on, what the user behind it can already do, and what to check in your own org.

Four tools do the work. discover finds actions by intent, describe returns the contract for one of them, and dispatch runs it, with dispatch_readonly as the read-only variant. There are others on the server - display_widget among them - but those four are the whole path from an intent to an executed call. The server is platform/headless-360, it needs an External Client App with the mcp_api scope (setup also requires refresh_token on that app), and it is off until an admin activates it under Setup > MCP Servers.

Two items on Salesforce's list of what agents can do with it are the ones a practitioner stops on: reading, writing and deploying Apex triggers, and creating named credentials "including authentication mechanisms, endpoints, and certificate handling."

Every transaction runs as the authenticated user through that External Client App. Object permissions, field-level security, sharing rules, profile permissions, and permission sets all apply, and the audit trail attributes the action to that user. There is no separate agent identity to point at. That is the premise for everything below, not the finding.

{  "tool": "dispatch_readonly",  "arguments": {    "url": "/services/data/v67.0/public/grid/workbooks",    "method": "GET"  } }

discover takes a natural-language description of what you want to do and returns candidate operations ranked against it. It has four parameters and only query is required. The schema describes the matching as a "hybrid semantic + keyword search across the API corpus." limit runs 1 to 50 and defaults to 10, and domain filters by AIP-103 domain such as platform or commerce.

resultType selects between the two kinds of things the library holds. An endpoint is a single API operation. A sor is a Setup Operation Recipe: a multi-step workflow with ordered steps, dependencies between them, and written guidance for the agent on how to run them. Unset, you get both.

Here is a real call, with domain and resultType left off:

{  "tool": "discover",  "arguments": {    "query": "query data in a grid worksheet built by Agentforce",    "limit": 10  } }

What you get back is a card per candidate, not the operation itself. Each carries a sor_id to pass to describe, a relevance score, a complexity band, a step_count, and an agent_description written for the model rather than for you - the first one reads "Build, run, and manage Agentforce Grid workbooks and worksheets to create AI-generated test cases, configure columns, execute worksheet runs, and evaluate agent behavior. Scope: agent testing workbench." The response also carries a filtered_out_count, which was 2 on this call.

Nothing is executable yet. To get there you call describe with one of those ids:

{  "tool": "describe",  "arguments": { "id": "shared-agentforce-grid-connect-api-sfdc.shared.agentforce.grid.connect.api-oas-67.0" } }

For a SOR, that returns the whole recipe. The grid one has 60 steps - 29 read, 18 write, 8 verify, 4 delete and 1 validate - along with its preconditions:

[  "Agentforce Grid entitlement is active on the org",  "User has appropriate permissions to manage workbooks and worksheets" ]

and agent_guidance, which is prose aimed at the model:

HAPPY PATH — Create workbook and generate test cases: get-agents → generate-test-columns → get-workbook (verify workbook created). Use agentId from get-agents as input to generate-test-columns.

{  "id": "get-dataspaces",  "description": "Retrieve available dataspaces to determine which data context to use for test generation or data model exploration.",  "api": "GET /services/data/v67.0/public/grid/dataspaces",  "api_type": "connect_api",  "purpose": "read",  "status": "implemented",  "output": {    "description": "Returns dataspaces array containing available dataspace identifiers and metadata.",    "schema_resolved": true  } }

That api field is where the chain closes. Split "GET /services/data/v67.0/public/grid/dataspaces" on the space and you have exactly the two things dispatch_readonly requires, method and url. Most write steps carry an inputs array naming each parameter and where it comes from - "Source: output of get-agents." Steps that only need an id take it from the path template in api instead. The eight verify steps carry depends_on, each pointing at the step it checks.

Pass describe a bare operation id instead of a SOR id and you get that one operation's OpenAPI detail rather than a workflow: method, path, request and response schemas, and the declared access checks.

What the agent can call is assembled at call time out of that library. It is not fixed when you connect the client.

When you approve a connected app you can read its scope, attach it to a change ticket and hand it to an auditor.

Headless 360 gives the agent a handful of tools. The things it can actually do live in what Salesforce calls "a continuously growing library of Salesforce operations," which sits server-side and expands with each release. From the docs: "Your agent's tool surface stays small and stable while the set of actions it can take scales independently." The agent finds out what is available by calling discover, which returns a ranked shortlist rather than a manifest. Some paths are withheld from it server-side — the xds-connect-api entry tells the agent that write and delete paths for external object rows are "daemon-only and filtered from the agent view" — but what that filter checks, and where else it applies, is not documented.

describe does not close the gap either. Here is a dispatch POST against the operation that converts natural language into SOQL. The response arrives with its quotes and angle brackets HTML-escaped in the stored value, so what comes back is not directly executable:

POST /services/data/v67.0/public/grid/generate-soql

{"text": "all accounts in the technology industry with revenue over 1 million"}

{  "soql": "SELECT Name, Industry, AnnualRevenue FROM Account WHERE Industry LIKE '%Technology%' AND AnnualRevenue > 1000000 LIMIT 50" }

describe gives that operation's declared access checks as org-access-check: "AI Workbench enabled" and user-access-check: "AI Workbench access", and says nothing about the Account data the generated query will eventually read, because generating a query and running it are different operations. The contract does not tell you an operation's data reach, which is the other half of what a scope review needs.

The user who authorizes the connection is the agent, and what that person is carrying is the ordinary state of a mature Salesforce org rather than a broken one.

Permissions accrete. A profile gets View All Data during an implementation because the integration consultant needed it to finish on time. Modify All Data gets granted for a data migration years ago and the project closes without anyone revoking it. Manage Sharing arrives inside a permission set group, or gets pushed to a whole role through Data Loader, so the assignment has no owner and nobody remembers approving it. Somebody clones a profile to make a new one and the clone inherits everything the original had collected. A developer moves to another team and keeps Author Apex. A support lead gets View All Data so they can see every Case, which is reasonable, and they keep it when they move into enablement, which is not.

None of this is exotic and none of it is anybody's fault in particular. Revoking a permission is work with no visible benefit and a real risk of breaking somebody's Tuesday, so it does not get done. The result is that the gap between what your users can do and what they do do is enormous, and it has been enormous for years.

The obvious answer is to connect MCP as a dedicated least-privilege user, and that is a genuinely good move which more orgs should make. It is also not what usually happens, because the admin who wants an agent that can deploy an Apex trigger has to authorize an account that can deploy Apex triggers, and the fastest such account to hand is their own. Whoever authorized your org's connection, the check that finds what they are carrying is in "Who has connected, and what they can do" below.

Holding a permission and using it are different things, and almost everything in a Salesforce org has been quietly enforcing that difference.

The Lightning UI surfaces a fraction of what a profile allows. A support lead with View All Data sees the Cases their list views are built around, not every Case in the org, because the interface only ever asks for the ones on screen. People do not know which Setup page exists, so the permission to use it sits idle. Integrations have fixed scopes that somebody reviewed once, years ago, and they have not widened since. Writing REST calls by hand against your own org is not how most people get through the day.

None of that was designed as a security control, and all of it has been working as one, with the permission matrix sitting behind it as a backstop - which is a large part of why it was allowed to rot.

Headless 360 removes those layers deliberately. Salesforce's framing of the launch was "No Browser Required" - the point is that an agent reaches the platform without the UI and without a fixed integration scope. An agent has no list views and no sense that a Setup page is obscure. It asks what operations exist, gets an answer, and calls one. The support lead who has had View All Data for three years and never once queried every Case in the org now has something attached to their account that will do exactly that, the first time a question makes it relevant.

Everything so far has been reads, and writes behave differently, because a request often has more than one way to satisfy it. Ask an agent to let somebody see a record: it can create a share, or it can widen the org-wide default for the whole object. Ask it for a public link to a file when the org setting that allows public links is switched off: it can report that the setting is off, or it can switch the setting on. The broad route in each pair needs a permission of its own — Manage Sharing for the org-wide default, Setup access for the file setting — which is to say that the admins and developers most likely to be wired to an MCP client have both routes open. Both end with the person able to see the thing they asked about. An admin picks the narrow one because they know the broad one changes the org for everybody, and that judgement is not in the permission set and not in the request.

Salesforce's documentation is direct about this. Per-user authentication means every call runs with the permissions of the user who authorized it, "the same field-level security, object access, and sharing rules that apply in Lightning," and the docs call this "a feature, not a constraint: it means that AI agents operate within your

正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。

打开原文
去社区讨论 →