Salesforce’s 8 Agentic Design Principles: What Changes for SFMC, Braze, and Iterable—Now

On March 23, 2026, Salesforce published its “8 Design Principles for the Agentic Enterprise.” The thesis is blunt: bolting agents onto brittle architectures fails because the stack—not the model—is the bottleneck. If you run Salesforce Marketing Cloud, Braze, or Iterable alongside a CRM and a CDP, this is your pre-mortem.

Sources: Read Salesforce’s principles here. Watch where enterprise AI is headed via Accenture’s investment in DaVinci Commerce on Mar 23, 2026—agent-led shopping is no longer theoretical (Accenture).

What happened

Salesforce laid out eight guardrails for building agentic systems. Through-line: agents need clear goals, verified data, enforceable policies, and runtime feedback loops. The document warns against pasting an agent over legacy pipelines and hoping for magic. In parallel, the market is moving the same way: Accenture is funding agentic commerce, and Alibaba International projects enterprise agentic AI next (Silicon Republic).

Why this matters to lifecycle teams on SFMC, Braze, or Iterable: your orchestration sits at the collision point of identity, content, channel ops, and measurement. Agents will amplify whatever exists—good or bad. If send eligibility rules, product catalog joins, and suppression governance aren’t explicit, you’ll scale chaos.

Why it matters for your stack

Salesforce’s message doubles as an implementation checklist:

• Architecture first: Agents require systems of record and engagement stitched with contracts, not ad hoc joins. If your SFMC Data Extensions, Braze Catalogs, or Iterable Data Feeds are “best guess,” the agent will propagate those errors into creative and audiences.
• Goals and rewards: Agents need measurable rewards. If journey objectives stop at “CTR,” you’ll optimize noise. Tie to revenue or retention in CRM/warehouse with attribution windows and negative rewards for spam complaints and failures.
• Policies at runtime: SOPs in Confluence won’t stop an agent at 2 a.m. You need enforcement in code—pre-send checks, SKU eligibility, and channel guardrails the runtime can’t bypass.
• Observability: If you can’t see what the agent saw, decided, and did, you can’t govern or improve it. Log prompts, inputs, constraints, and outputs with lineage. That aligns with our take in AI agents need observability.

Salesforce has been telegraphing this shift: GPU alignment for Agentforce (Salesforce x NVIDIA), agentic work-unit pricing, and now design principles. Pattern: agent workloads move from pilots to production economics. If you’re still debating “should we use agents,” you’re late. The question is “what can our architecture let an agent do safely?”

The hidden risks marketers underestimate

• Identity drift: If CustomerID mapping across CRM, data cloud, and SFMC/Braze/Iterable isn’t deterministic with fallbacks, agents will create audiences that fragment consent and personalization. Expect hard bounces and frequency blow-ups.
• Catalog ambiguity: If product or content catalogs don’t carry stock status, margin, or regulatory flags as fields the agent can read, it will select “great content” that’s out of stock, off-brand, or non-compliant.
• Time windows: Agents need lookbacks and cooldowns as first-class constraints. Without them, on-demand experimentation becomes near-duplicate sends that hurt deliverability.
• Shadow data: Agents query whatever’s visible. If staging tables, sandboxes, or stale exports are exposed, they’ll be used. Curate the surface area.

What teams should do this quarter

Use Salesforce’s principles to tighten the lifecycle stack you have.

1. Define agent-safe data contracts

• SFMC: Lock DE schemas for audiences, catalog, and eligibility. Add stock_status, compliance_flag, and last_contact_ts; document semantics.
• Braze: Use Catalogs and Custom Events with explicit keys. Add Catalog Item Attributes for eligibility and region. Enforce via Connected Content validations.
• Iterable: Materialize user and event tables with versioned schemas. Add suppression_reason and contactability_state. Validate through data pipelines before journeys.

2. Enforce pre-flight policies in code

• Implement pre-send validators: audience size deltas, suppression overlap, frequency caps, and SKU eligibility. Fail hard on breach.
• Centralize consent and contactability in CRM/warehouse and make it read-only at the channel level.

3. Instrument observability and lineage

• Log input datasets, constraints, prompts (or decision trees), selected variants, and outcomes. Tag every send with decision_id and data_version.
• Route logs to your warehouse and a review dashboard. Alert on anomalies (e.g., +50% frequency week-over-week for any segment).
• See our primer: Observability is the missing RevOps control plane.

4. Tie rewards to business outcomes

• Set reward functions that include margin or LTV—not just CTR. Penalize unsubscribes, spam complaints, and returns. Connect to CRM opportunities or orders via order_id/opp_id joins.

5. Limit the blast radius

• Use scoped sandboxes and staged rollouts: 1%, then 10%, then 25% with automated rollback if KPI guardrails breach.

A quick read on platform specifics

• Salesforce Marketing Cloud: Use Entry Events with decisioning fed by governed DEs and Query Activities that reference only whitelisted views. Marketing Cloud guidance now points to architecture over prompts (Salesforce principles).
• Braze: Orchestrate with Canvas Flow but move dynamic selection into Catalogs and Connected Content with validation layers; use Braze Cloud Data Ingestion to source only certified tables. Cross-check with insights from the 2026 Braze Customer Engagement Review on trust and transparency (Yahoo Finance summary).
• Iterable: Gate AI-assisted content and audience generation behind pre-flight policies and measurement plans; Iterable’s leadership has long argued for systems that learn and adapt—use that, but constrain with contracts (see trend via Mi-3’s writeup on iterative planning culture in 2025 here).

Key takeaway

Agents don’t fix architecture. They expose it. If identities, catalogs, policies, and observability are explicit and enforced, agents accelerate testing and personalization. If not, they multiply variance and risk.

If your SFMC, Braze, or Iterable instance shows fragile joins, unclear eligibility, or zero lineage on AI decisions, that’s what we sort out in a working session.