Designing Products for AI Agents: Lessons from Salesforce Headless 360

Why product design must change for AI agents

In April 2026 Salesforce announced Headless 360 with the bold claim “no browser needed,” sparking a debate about the future of CRM and raising a key question: as AI agents become the main callers of a product, how should the product be designed? By combining Salesforce documentation, VentureBeat reports, and real‑world cases, the article breaks down the core logic and actionable path for the Agent era.

Core insight: from human UI to agent actions

Traditional software design centers on human interaction—clear interfaces and smooth flows. With agents, the conflict shifts to enabling agents to precisely understand, reliably invoke product capabilities, and satisfy enterprise determinism and compliance. Claude Code’s “Seeing like an Agent” paper emphasizes that tools must be described as actions (name, parameters, return values, constraints) rather than UI buttons.

Headless 360’s practical validation

Headless 360 does not abandon the UI; instead it extracts product capabilities from the UI into standardized, open forms that agents can call without a browser, while protecting data, processes, permissions, and audit layers. The core goal is to turn capabilities into agent‑readable, callable, constrained, and auditable actions.

1. Multi‑mode invocation

MCP tools & pre‑configured skills : 60+ MCP (Model Context Protocol) tools and 30+ coding skills let external AI coding agents such as Claude Code, Cursor, Codex, and Windsurf directly access data queries, workflow operations, and business logic.

API & CLI commands : Traditional API remains, while CLI is hardened for agents with --help, --json, exit codes, and a non‑interactive mode for fast, composable calls.

Agentforce Experience Layer : Separates functional logic from presentation, allowing a single action definition to be deployed to Slack, Microsoft Teams, ChatGPT, Gemini, mobile, etc., without writing platform‑specific code.

The design principle is “split the entry point, keep the foundation”: the UI stays for approval and error handling, but the product now offers both a human‑visible interface and an agent‑usable call layer.

2. Semantic layer – a readable specification for agents

Standardized documentation : Provides llms.txt (index), OpenAPI specs, and skill.md (ability summary) so agents can directly read actions, required parameters, and constraints.

Progressive information disclosure : Instead of loading all docs into the system prompt, agents first receive an index and fetch details on demand, avoiding overload.

Error‑feedback contracts : Defines explicit error formats and recovery guidance, enabling agents to detect failures and retry or roll back automatically.

This turns documentation from a post‑sale aid into an integral part of the product interface; for example, Notion’s MCP tool is easier for agents than Slack’s because Notion supplies a clear Markdown schema.

3. Determinism guarantee – Agent Script and lifecycle governance

Agent Script : An open‑source, domain‑specific language stored as versioned flat files, supporting if/else, state transitions, variable management, and ordered actions. It clearly separates LLM‑generated reasoning from enforced business rules.

Full‑lifecycle governance tools : Testing Center (exposes logic bugs and policy violations), Custom Scoring Evals (defines agent qualification criteria), and A/B Testing API (parallel version testing). VentureBeat notes early Agentforce customers had to redo all tests after a single prompt change.

4. Scenario‑specific adaptation

Salesforce distinguishes two agent scenarios that share the same platform and graph engine but differ in control intensity:

Customer‑facing (support, after‑sales, inquiry) : Uses static flowcharts with fixed steps, emphasizing compliance, brand rules, determinism, and auditability. Human role is fallback and approval.

Employee‑facing (coding, sales research, content generation) : Employs dynamic task graphs that decide paths at runtime, focusing on efficiency, exploration, tool coverage, and context quality. Human role is review and decision.

This avoids a one‑size‑fits‑all approach, balancing compliance risk and flexibility.

5. Five‑layer stack for agent‑friendly products

Surface layer : Multi‑terminal entry points (Slack, Teams, ChatGPT, etc.).

Invocation layer : Stable, discoverable APIs/CLI/MCP/Hosted Server with robust authentication and flow control.

Semantic layer : Tool description, schema, policy, error contracts, and examples that determine call accuracy.

Business foundation : Long‑term data, processes, logic, integration relationships, and assets that constitute core SaaS value.

Governance layer : Authentication, authorization, audit, testing, evaluation, observation, rollback, and billing to enable scalable agent deployment.

Most products today have weak semantic and governance layers.

Practical 5‑step guide to refactor a product

Atomize high‑frequency capabilities into single‑responsibility actions, expose them via a CLI with --help, --json, --exit‑code, --dry‑run, and non‑interactive mode for low‑cost agent trials.

Migrate UI‑level permission and audit logic to the platform layer so agents inherit the same security rules (object/field security, sharing, profile permissions) and all operations remain traceable.

Build a machine‑readable semantic layer using Notion‑style documentation: separate boundary description from detailed resources, making tools self‑explanatory for agents.

Introduce a feedback loop by attaching a rationale parameter to each tool call and designing a structured feedback endpoint to capture failure paths, enabling precise product optimization.

Implement full lifecycle governance: offline testing, custom scoring, observability, failure replay, and version rollback to close the “cannot modify after launch” loop for agents.

Industry insight

Headless 360 demonstrates that agents will not kill SaaS products; instead they expand the value boundary from UI to the underlying data, permissions, processes, and audit requirements. Competitive advantage shifts from “smooth UI” to “open capabilities, semantic support, and controllable governance.” Products that let agents “read, invoke, and be governed” will dominate the AI era.