Dreamforce 2025 Takeaways: Agentforce 360 and the Agentic Enterprise Reality Check

cto_michelle · October 21, 2025, 4:48am

Just returned from Dreamforce 2025 (Oct 14-16) in San Francisco, and I need to share my thoughts on Salesforce’s biggest bet: Agentforce 360 and the shift to an “Agentic Enterprise.”

Marc Benioff’s keynote was bold - declaring we’re entering a new era where AI agents work alongside humans (not replacing them). But as CTOs, we need to separate the vision from the reality of implementation.

The Big Picture: What is the “Agentic Enterprise”?

Benioff’s core thesis: Organizations are moving from human-only workforces to hybrid teams of humans and AI agents. The “Agentic Enterprise” is one where autonomous AI agents handle routine tasks, escalate complex issues to humans, and continuously learn from both.

Key quote from keynote: “AI does not replace humans. It elevates them. The companies that understand this will lead the next decade.”

My take: This is directionally correct, but the devil is in the details of trust, governance, and integration.

Agentforce 360 Platform Overview

Salesforce announced Agentforce 360 as their unified platform for deploying AI agents across the enterprise:

Core Components:

1. Agent Builder

Conversational development studio (natural language)
No-code/low-code agent creation
Test and deploy agents without manual configuration
Version control and rollback capabilities

2. Agent-to-Agent Communication

Agents can delegate tasks to other specialized agents
Example: Sales agent passes lead qualification to Marketing agent
Orchestration layer handles routing and context preservation

3. Model Flexibility (Bring Your Own LLM)

Support for OpenAI, Anthropic, Google, Cohere, or custom models
Unified API regardless of underlying model
Governance controls maintained across all models

4. Pre-Built Industry Agents

300+ ready-to-deploy agents
Verticals: Financial Services, Healthcare, Manufacturing, Retail
Example agents: SDR Agent, Service Agent, Marketing Campaign Agent

5. Unified Data Layer (Data 360)

Formerly “Data Cloud”
Real-time data harmonization across Salesforce and external systems
Intelligent Context: Turns unstructured data into agent-usable context
Tableau Semantics integration for analytics

Architecture (Simplified):

┌─────────────────────────────────────────────┐
│         Agentforce 360 Platform             │
├─────────────────────────────────────────────┤
│  Agent Builder  │  Agent Orchestrator       │
│  (Dev Studio)   │  (Multi-Agent Routing)    │
├─────────────────┴───────────────────────────┤
│         LLM Abstraction Layer               │
│  (OpenAI, Anthropic, Google, Custom)        │
├─────────────────────────────────────────────┤
│         Governance & Trust Layer            │
│  (Access Control, Audit, Compliance)        │
├─────────────────────────────────────────────┤
│              Data 360                       │
│  (Unified Enterprise Data + Context)        │
├─────────────────────────────────────────────┤
│  Salesforce Apps: Sales, Service, Marketing │
│  + Slack, Tableau, MuleSoft                 │
└─────────────────────────────────────────────┘

Real Customer Examples from Keynote

Salesforce showcased several companies already using Agentforce:

1. OpenAI

Use case: Customer support automation
Result: 30% reduction in support ticket volume
Agent handles: Documentation queries, API troubleshooting, billing questions

2. Williams-Sonoma

Use case: Personalized shopping assistant
Result: 15% increase in conversion rate
Agent handles: Product recommendations, inventory checks, order tracking

3. PepsiCo

Use case: Route optimization for delivery
Result: 12% fuel cost savings
Agent handles: Real-time route adjustments based on traffic and demand

4. FedEx

Use case: Shipment exception resolution
Result: 40% faster resolution time
Agent handles: Automated rebooking, customer notifications, carrier coordination

5. Dell Technologies

Use case: IT asset management
Result: 50% reduction in manual provisioning time
Agent handles: Hardware requests, software licensing, decommissioning

The CTO Reality Check: What I’m Cautious About

1. Speed of Innovation vs Speed of Adoption

Benioff acknowledged this: “The speed of innovation is far exceeding the speed of customer adoption.”

Translation: Salesforce is releasing features faster than most enterprises can absorb them.

My concern:

Our teams are still mastering Einstein AI (previous generation)
Now we’re expected to deploy 300+ agents?
Risk of “shelfware” - licensed but unused

2. Integration Complexity

Agentforce 360 promises to integrate with Sales, Marketing, Commerce, Slack, Tableau, and MuleSoft.

Reality:

Most enterprises have custom integrations, legacy systems, and non-Salesforce tools
Data 360 requires significant data engineering effort
Multi-agent orchestration adds architectural complexity

Questions I have:

How do agents handle failures in upstream/downstream systems?
What’s the latency for cross-agent communication?
How do we debug agent decision-making?

3. Governance and Compliance

“Pre-built governance controls” sounds great, but:

Concerns:

Who is accountable when an agent makes a mistake?
How do we audit agent actions across 100+ concurrent agents?
GDPR/HIPAA compliance for agent data access?
Model drift: How do we ensure agents don’t degrade over time?

4. Cost Model Uncertainty

Salesforce introduced a new Agentic Enterprise License Agreement:

Bundled unlimited Agentforce + Data 360
Action-based pricing (per agent action)
Flex credit model

Problem: Unpredictable costs.

How many “actions” will our use cases consume?
What happens if agent usage spikes unexpectedly?
TCO analysis is challenging without historical data

5. Bring Your Own LLM: Sounds Good, But…

Model flexibility is a selling point, but:

Challenges:

Different models have different strengths/weaknesses
Performance tuning per model
Cost optimization across multiple providers
Lock-in risk if we invest heavily in Salesforce’s orchestration layer

What Impressed Me

Despite my concerns, several things stood out:

1. Agent Builder Demo

Watched a live demo: Created a “Sales Discovery Agent” in 10 minutes using natural language prompts.

Workflow:

Describe agent purpose: “Help SDRs qualify leads”
Define data sources: Salesforce Lead object, LinkedIn, company website
Set guardrails: “Only proceed if company has 50+ employees”
Test with sample leads
Deploy to pilot team

No code written. This is genuinely impressive for rapid prototyping.

2. Slack as “Agentic OS”

Slack integration is deeper than expected:

Channel Expert Agent: Always-on assistant that knows context of channel history
Enterprise Search: Query across Salesforce, Google Drive, GitHub, Jira from Slack
Slack-First Apps: Agentforce agents surface insights directly in Slack

This resonates because our teams already live in Slack. Lowering the friction to AI.

3. Real-Time Data Harmonization

Data 360’s “Intelligent Context” feature:

Automatically unifies customer data from multiple sources
Creates semantic layer for agents
Updates in near-real-time (< 1 minute latency)

If this works as advertised, it solves a major pain point: keeping customer data synchronized.

The 12,000 Customers Question

Salesforce claims 12,000+ customers are experimenting with Agentforce.

Reality check:

“Experimenting” ≠ Production deployment
How many have moved beyond pilot?
What’s the success rate?
Would love to see case studies with ROI metrics

My Recommendations for Our Organization

Based on Dreamforce, here’s my plan:

Phase 1: Pilot (Q1 2026)

Start with 1-2 narrow use cases
- Customer Service: Automate tier-1 support tickets
- Sales: Lead qualification assistant
Limited scope: 10-20 users max
Success metrics: Response time, user satisfaction, accuracy rate

Phase 2: Evaluate (Q2 2026)

Measure pilot results
TCO analysis: License costs + engineering time + maintenance
Governance audit: Compliance review, security assessment
Integration testing: Stress test with our tech stack

Phase 3: Expand or Pivot (Q3 2026)

If pilots succeed: Expand to more use cases
If not: Evaluate alternatives (Microsoft Copilot, custom agents)

Phase 4: Scale (2027)

Multi-agent workflows
Agent-to-agent communication
Cross-functional orchestration

Timeline: 18 months to production-scale deployment.

Questions for the Community

1. Is anyone else deploying Agentforce? What use cases are you starting with?

2. Integration architecture: How are you handling Data 360 integration with existing data warehouses (Snowflake, BigQuery)?

3. Governance: What frameworks are you using for AI agent accountability and compliance?

4. Bring your own LLM: Has anyone tested this? Performance comparison vs Salesforce’s default models?

5. ROI measurement: What KPIs are you tracking for AI agent success?

My Bottom Line

Agentforce 360 is real, but it’s early.

The vision of an “Agentic Enterprise” is compelling, and Salesforce has built impressive infrastructure. But enterprise adoption will be measured in years, not months.

Key takeaway: Start small, measure obsessively, scale cautiously.

The companies that master AI agents will have a competitive advantage. But rushing into this without a clear strategy and governance model is a recipe for expensive failure.

Michelle Chen
CTO @ TianPan

Resources:

Dreamforce 2025: October 14-16, Moscone Center, San Francisco
Agentforce 360 announcement: Agentforce: The AI Agent Platform | Salesforce
Marc Benioff keynote: Dreamforce 2025 | Salesforce
Agentforce Builder documentation: https://developer.salesforce.com/docs/agentforce
Data 360 overview: https://www.salesforce.com/data-cloud/

alex_infrastructure · October 21, 2025, 4:48am

Michelle, excellent strategic overview. Let me add the infrastructure and scaling perspective - I spent the last two days at Dreamforce in the “Enterprise Architecture” track focused on how to actually run this at scale.

Infrastructure Requirements for Agentforce 360

Compute & Memory

Data 360 Platform Requirements (from Salesforce engineering team):

Minimum (Development/Testing):

4 vCPUs, 16GB RAM
100GB storage (SSD)
10 Mbps network

Production (100-500 users):

16 vCPUs, 64GB RAM
1TB storage (NVMe SSD)
1 Gbps network
99.9% uptime SLA

Enterprise Scale (5,000+ users, 100+ concurrent agents):

64+ vCPUs, 256GB+ RAM
10TB+ storage (distributed across nodes)
10 Gbps network with redundancy
99.99% uptime SLA
Multi-region deployment

Real-Time Data Sync Challenges

Data 360’s “< 1 minute latency” claim:

In the deep dive session, Salesforce engineers revealed the architecture:

External Systems → Change Data Capture (CDC)
                     ↓
                MuleSoft Integration Layer
                     ↓
                Data 360 Ingestion API
                     ↓
                Event Stream Processing (Kafka)
                     ↓
                Data Harmonization Engine
                     ↓
                Unified Customer Graph
                     ↓
                Available to Agents (< 60 seconds)

My concerns:

CDC overhead: Capturing changes from legacy systems requires database triggers or log parsing
Network latency: Cross-region data sync adds 100-300ms
Harmonization complexity: Merging conflicting records (e.g., different customer IDs) takes time
Peak load: What happens during batch imports or system migrations?

Recommendation: Plan for 2-5 minute latency in real-world deployments, not 1 minute.

Agent-to-Agent Communication Overhead

Multi-agent workflows introduce new bottlenecks:

Example scenario: Sales agent → Marketing agent → Data enrichment agent

1. Sales Agent receives lead (10ms processing)
2. Calls Marketing Agent API (50ms network + 200ms LLM inference)
3. Marketing Agent queries Data 360 (100ms)
4. Calls Data Enrichment Agent (50ms network + 300ms external API)
5. Response propagates back through chain (250ms)

Total latency: ~960ms for 3-agent workflow

Scaling implications:

100 concurrent multi-agent workflows = 96 seconds of total compute time
Need load balancing, request queuing, and circuit breakers
Monitoring becomes critical (distributed tracing required)

Cost Analysis: AWS Deployment

Estimated monthly AWS costs for 1,000 users:

Compute (ECS Fargate):

10 tasks × m5.xlarge equivalent = $1,200/month

Data 360 Storage (S3 + RDS):

5TB customer data = $115/month (S3)
500GB relational data (PostgreSQL) = $180/month

Network:

Data transfer out: 2TB/month = $180/month
VPN/Direct Connect to Salesforce: $300/month

LLM API Costs (GPT-4):

10M tokens/day × $0.03/1K tokens = $9,000/month

Total: ~$11,000/month (excluding Salesforce licenses)

Add Salesforce Agentic Enterprise License: $150-$300 per user/month

Full TCO: ~$161,000/month for 1,000 users

Performance Benchmarks (from Dreamforce Lab)

I ran load tests in the Salesforce Developer Zone:

Single Agent Performance:

Simple query (CRM lookup): 150ms average
Complex reasoning (multi-step): 800ms average
External API calls: 1,200ms average

Concurrent Agent Scaling:

10 concurrent agents: 200ms average latency
50 concurrent agents: 350ms average latency
100 concurrent agents: 600ms average latency (throttling kicks in)

Bottleneck: LLM inference time dominates. Caching frequently-asked questions helps.

Observability & Monitoring

What you MUST monitor:

Agent Request Latency (p50, p95, p99)
Agent Error Rate (% of failed requests)
Data 360 Sync Lag (freshness of data)
LLM Token Usage (cost control)
Agent-to-Agent Hop Count (orchestration complexity)

Tools recommended:

Datadog APM for distributed tracing
Prometheus + Grafana for metrics
Salesforce Event Monitoring (native)
Custom dashboards for agent-specific KPIs

Multi-Cloud Strategy

Salesforce runs on AWS, but our infrastructure is on GCP.

Challenges:

Cross-cloud egress costs ($0.08-$0.12 per GB)
Latency: 20-50ms added for cross-cloud calls
VPN or Direct Connect required

Recommendation:

If heavily invested in GCP: Use Salesforce’s new multi-cloud connector (announced at Dreamforce)
Evaluate hybrid approach: Keep Data 360 close to Salesforce (AWS), sync to GCP data warehouse

Kubernetes Integration

For teams running Kubernetes:

Salesforce released an Agentforce Kubernetes Operator (beta):

Deploy agents as Kubernetes CRDs (Custom Resource Definitions)
Autoscaling based on agent request volume
Integrated with Istio service mesh for traffic management

Example CRD:

apiVersion: agentforce.salesforce.com/v1
kind: Agent
metadata:
  name: sales-discovery-agent
spec:
  model: gpt-4
  dataSource: salesforce-crm
  replicas: 5
  autoscaling:
    minReplicas: 2
    maxReplicas: 20
    targetCPUUtilization: 70
  resources:
    requests:
      memory: "2Gi"
      cpu: "1"
    limits:
      memory: "4Gi"
      cpu: "2"

This is promising for cloud-native teams. Still beta, but shows Salesforce understands Kubernetes dominance.

My Infrastructure Recommendations

1. Start with managed Salesforce infrastructure (don’t self-host initially)

Let Salesforce handle scaling, patching, uptime
Reduces operational burden during pilot phase

2. Plan for 3x your estimated load

Agent usage is unpredictable (users experiment)
Better to overprovision than face throttling

3. Implement aggressive caching

40% of agent queries are repetitive (from my testing)
Redis or Memcached for frequent responses
Reduces LLM API costs significantly

4. Use multi-region deployment for global teams

Salesforce supports US, EU, APAC regions
Keeps data residency compliant (GDPR)
Reduces latency for international users

5. Budget for LLM costs separately

Variable and can spike unexpectedly
Set up billing alerts and usage quotas
Consider switching to cheaper models for non-critical agents

Questions for Michelle and the Team

What’s our current data sync latency from our systems to Salesforce? This will be the baseline for Data 360 performance.
Do we have budget for the $11K+/month infrastructure costs I estimated?
Which cloud provider should we standardize on for Agentforce workloads?
Monitoring tools: Should we extend our existing Datadog setup or use Salesforce’s native monitoring?

Infrastructure-wise, Agentforce 360 is architected well for scale. But it requires significant investment in infrastructure, monitoring, and operational discipline.

Alex Chen
Infrastructure Lead @ TianPan

priya_security · October 21, 2025, 4:48am

Michelle and Alex, great insights. From the security and governance side, I attended every compliance and security session at Dreamforce. Here’s what keeps me up at night about deploying AI agents at scale.

Security Model: Who Can Agents Impersonate?

Key question: When an agent acts, whose permissions does it use?

Dreamforce answer: Agentforce uses delegated authentication.

How it works:

User → Requests agent action
       ↓
Agent → Authenticates as ServiceAccount_AgentBot
       ↓
Agent → Checks user's permissions via Salesforce Sharing Model
       ↓
Agent → Only accesses data user could access
       ↓
Action → Logged with both user ID and agent ID

This is good: Agents can’t bypass user permissions.

This is concerning: Service account needs broad read access to function effectively.

Example vulnerability:

Agent has read access to all customer records
User asks: “Show me all customers in California with revenue > $1M”
Agent returns data user shouldn’t see if query is too broad
Data leakage through overly helpful agents

Mitigation: Implement query result limits and data filtering at agent level.

Governance Controls: What Salesforce Offers

Pre-built governance features announced:

1. Agent Access Policies

Define which users can invoke which agents:

Sales Discovery Agent:
  - Allowed Roles: Sales Rep, Sales Manager
  - Allowed Actions: Read leads, Create tasks, Send emails
  - Forbidden Actions: Delete records, Modify pricing
  - Data Scope: Own team's leads only

2. Audit Trail

Every agent action logged:

Timestamp
User who invoked agent
Agent ID
Action taken (API call, data access, external system call)
Input/output (can be redacted for PII)
Success/failure status

Retention: 90 days standard, up to 10 years for compliance

3. Content Filtering

Agents use Salesforce Shield:

PII detection (SSN, credit cards, phone numbers)
Profanity filtering
Toxic content blocking
Proprietary data leak prevention

Example: Agent won’t return customer SSN even if asked directly.

4. Model Input/Output Monitoring

For “bring your own LLM”:

Monitor prompts sent to external models
Scan for injection attacks (“Ignore previous instructions…”)
Block sensitive data from leaving Salesforce
Rate limiting per model/user

Compliance: GDPR, HIPAA, SOC 2

GDPR (Right to be Forgotten):

Challenge: Agent decisions based on user data. If user requests deletion, how do we ensure agents don’t retain knowledge?

Salesforce’s approach:

Data 360 deletes user records within 30 days
Agent caches purged immediately
Re-training not required (agents use real-time data, not fine-tuned models)

My concern: 30 days feels long. GDPR requires “without undue delay.”

HIPAA (Healthcare Data):

Salesforce offers HIPAA-compliant Agentforce deployment:

PHI encrypted at rest and in transit
Agent logs don’t persist PHI
Dedicated infrastructure (no multi-tenant)
Business Associate Agreement (BAA) required

Cost premium: 2-3x standard pricing.

SOC 2 Type II:

Salesforce maintains SOC 2 certification for Agentforce:

Annual audits
Controls for availability, confidentiality, processing integrity
Access reviews every 90 days

Our responsibility: Ensure our agent configuration doesn’t undermine their controls.

Bring Your Own LLM: Security Implications

Michelle asked about this. Here’s the security reality:

Scenario: We use OpenAI GPT-4 via Agentforce.

Data flow:

User query → Salesforce → OpenAI API → GPT-4 inference
                              ↓
                     Returns to Salesforce

Security questions:

Does OpenAI store our queries? (Yes, for 30 days per their policy)
Is our data used for model training? (No, if we use API - but verify in contract)
What if OpenAI is breached? (Our customer data could leak)
Compliance: Is OpenAI GDPR/HIPAA compliant for our use case? (Check BAA)

Recommendation:

For sensitive data: Use Salesforce’s default models (hosted in their infrastructure)
For non-sensitive use cases: External models OK with proper contracts

Agent-to-Agent Trust Boundaries

Multi-agent workflows create new attack surface:

Example attack:

Malicious Sales Agent → Sends crafted payload to Marketing Agent
                                ↓
                        Marketing Agent executes unvalidated
                                ↓
                        Accesses customer PII it shouldn't

How to prevent:

Agent authentication: Agents verify each other via API keys
Input validation: Receiving agent sanitizes all inputs
Least privilege: Each agent has minimal data access
Rate limiting: Prevent agent-to-agent DOS attacks

Dreamforce recommendation: Use Salesforce’s Agent Orchestrator (handles trust automatically).

My concern: Adds another dependency. What if orchestrator has a bug?

Accountability: When Agents Make Mistakes

Real scenario from Dreamforce customer:

“Our Service Agent auto-approved a $50,000 refund due to misunderstanding a customer request. Who is liable?”

Salesforce’s answer:

Agent actions are logged (user + agent)
Implement approval workflows for high-value actions
Use confidence scores: Agent says “I’m 60% confident” → escalate to human
Error rate SLAs in Enterprise License Agreement

My legal team’s answer:

Company is ultimately liable
Agent is a tool, not a legal entity
Need insurance for AI-related errors

Recommendation:

Set monetary thresholds (e.g., refunds > $1,000 require human approval)
Pilot with low-risk use cases first

My Security Recommendations

Phase 1: Pilot

Limit agent access to non-PII, non-PHI data
Single use case (e.g., lead qualification)
Max 10 users, security team included
Daily security review of agent logs
Disable agent-to-agent communication

Phase 2: Expand

Conduct internal security audit
Pen test agent endpoints
Red team exercise: Try to trick agents
Enable full audit logging (keep 1 year minimum)
Implement data loss prevention (DLP) rules

Phase 3: Production

External security audit (required for SOC 2)
GDPR compliance review with legal
Incident response plan for agent failures
Quarterly access reviews
Enable agent-to-agent communication with strict policies

Questions for Michelle and Team

What’s our risk tolerance? Some use cases (e.g., marketing) can tolerate errors. Others (finance, legal) cannot.
Do we have a Data Protection Officer (DPO)? Required for GDPR if processing EU citizen data.
Insurance: Do we have cyber liability insurance that covers AI agent errors?
Red team: Can we run a security exercise before production deployment?

Security-wise, Agentforce has the right building blocks. But we need to configure and monitor it correctly.

Priya Sharma
Head of Security @ TianPan

maya_builds · October 21, 2025, 4:48am

Michelle, Alex, Priya - great strategic and operational perspectives. Let me add the hands-on developer view. I spent most of Dreamforce in the Developer Zone building actual agents. Here’s what worked and what frustrated me.

Developer Experience: Agent Builder Hands-On

I built 3 agents during the conference:

Lead Scoring Agent (Sales use case)
Bug Triaging Agent (Engineering use case)
Expense Approval Agent (Finance use case)

Time to first working agent: 23 minutes (Lead Scoring Agent)

Time to production-ready agent: 4 hours (after testing and refinement)

Agent Builder Workflow

Step 1: Describe Your Agent (Natural Language)

Prompt: "Create an agent that scores leads based on company size,
industry, and engagement history. Leads with score > 80 should be
assigned to senior sales reps."

Agent Builder response:
✓ Identified data sources: Lead object, Account object, Activity history
✓ Created scoring logic (editable)
✓ Generated assignment rules
✓ Proposed test cases

This was impressive - zero code, just conversation.

Step 2: Configure Data Sources

Agent Builder shows available data sources:

Salesforce objects (Lead, Account, Contact, etc.)
External systems (via MuleSoft connectors)
Custom APIs (provide OpenAPI spec)

Selected:

Lead (standard fields + custom fields)
Account (employees, industry, revenue)
ActivityHistory (emails, calls, meetings)

Step 3: Define Agent Logic

Agent Builder generated this logic (simplified):

def score_lead(lead):
    score = 0

    # Company size scoring
    if lead.company.employees > 1000:
        score += 30
    elif lead.company.employees > 100:
        score += 20
    else:
        score += 10

    # Industry scoring
    if lead.industry in ["Technology", "Financial Services"]:
        score += 25

    # Engagement scoring
    engagement_count = count_activities(lead, days=30)
    if engagement_count > 10:
        score += 30
    elif engagement_count > 5:
        score += 15

    # Assign to rep
    if score > 80:
        assign_to = "senior_sales_rep"
    else:
        assign_to = "junior_sales_rep"

    return {
        "score": score,
        "assignment": assign_to,
        "reasoning": f"Scored {score} based on company size, industry, and {engagement_count} interactions"
    }

I could edit this logic - not locked into generated code.

Step 4: Test with Sample Data

Agent Builder provides test leads:

Lead A: Acme Corp, 5000 employees, Technology → Score: 85, assigned to senior rep ✓
Lead B: Small Biz, 20 employees, Retail → Score: 30, assigned to junior rep ✓
Edge case: Missing employee data → Agent requested clarification (good!)

Step 5: Deploy

Options:

Sandbox (for testing)
Production (with approval workflow)
Scheduled (run nightly)
Real-time (trigger on lead creation)

I deployed to sandbox, then production after 2 days of testing.

SDK and API Integration

For developers who want more control, Salesforce offers:

Agentforce SDK (TypeScript/Python)

import { AgentforceClient, Agent } from '@salesforce/agentforce-sdk';

const client = new AgentforceClient({
  instanceUrl: 'https://yourinstance.salesforce.com',
  accessToken: process.env.SF_ACCESS_TOKEN
});

// Create agent programmatically
const agent = await client.agents.create({
  name: 'Lead Scoring Agent',
  model: 'gpt-4',
  dataSources: ['Lead', 'Account', 'ActivityHistory'],
  instructions: 'Score leads based on company size, industry, engagement',
  actions: [
    {
      type: 'update_field',
      object: 'Lead',
      field: 'Score__c'
    },
    {
      type: 'assign_owner',
      object: 'Lead'
    }
  ]
});

// Invoke agent
const result = await agent.execute({
  leadId: '00Q1234567890ABC'
});

console.log(result);
// Output: { score: 85, assignment: 'senior_sales_rep', reasoning: '...' }

This is clean and familiar for developers. Feels like any modern API.

REST API (for non-Salesforce platforms)

curl -X POST https://api.salesforce.com/agentforce/v1/agents/execute \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "agentId": "0Ag1234567890ABC",
    "input": {
      "leadId": "00Q1234567890ABC"
    }
  }'

# Response:
{
  "agentId": "0Ag1234567890ABC",
  "executionId": "0Ex1234567890ABC",
  "result": {
    "score": 85,
    "assignment": "senior_sales_rep",
    "reasoning": "Scored 85 based on company size (30), industry (25), 12 interactions (30)"
  },
  "latency": 450,
  "tokensUsed": 1234
}

Integration with CI/CD Pipelines

Can we version control agents?

Yes! Agents can be exported as YAML:

apiVersion: agentforce/v1
kind: Agent
metadata:
  name: lead-scoring-agent
  version: 1.2.0
spec:
  model: gpt-4
  temperature: 0.7
  dataSources:
    - name: Lead
      fields: [Company, Industry, Status, CreatedDate]
    - name: Account
      fields: [NumberOfEmployees, Industry, AnnualRevenue]
    - name: ActivityHistory
      dateRange: last_30_days
  logic: |
    Score leads based on:
    1. Company size (10-30 points)
    2. Industry match (0-25 points)
    3. Engagement level (0-30 points)

    Assign to senior rep if score > 80, else junior rep.
  actions:
    - type: update_field
      object: Lead
      field: Score__c
    - type: assign_owner
      rules:
        - condition: score > 80
          owner: senior_sales_queue
        - condition: score <= 80
          owner: junior_sales_queue
  testing:
    testCases:
      - input: { leadId: "00Q..." }
        expectedScore: 85
        expectedAssignment: senior_sales_rep

Store in Git → Deploy via CI/CD:

# In GitHub Actions or Jenkins
sf agentforce deploy --source agents/lead-scoring-agent.yaml --target production

This is a game-changer for treating agents as code.

Debugging and Observability

How do you debug an agent that makes wrong decisions?

Agent Execution Logs (in Salesforce UI):

Execution ID: 0Ex1234567890ABC
Agent: Lead Scoring Agent
Timestamp: 2025-10-15 14:32:01 UTC
User: [email protected]

Input:
  leadId: 00Q1234567890ABC

Data Retrieved:
  Lead.Company: "Acme Corp"
  Account.NumberOfEmployees: 5000
  ActivityHistory: 12 interactions (last 30 days)

Agent Reasoning (LLM output):
  "Company size: 5000 employees → 30 points
   Industry: Technology → 25 points
   Engagement: 12 interactions → 30 points
   Total score: 85 → Assign to senior rep"

Actions Taken:
  1. Updated Lead.Score__c = 85
  2. Assigned to senior_sales_queue

Latency: 450ms
Tokens Used: 1,234
Cost: $0.037

This level of transparency is critical for debugging.

Pro tip: You can export logs to Datadog, Splunk, or S3 for analysis.

Challenges I Encountered

1. Agent Hallucinations

Problem: Agent made up data that didn’t exist.

Example: Agent claimed lead had “attended 3 webinars” when activity log showed only emails.

Root cause: LLM filled in missing data with plausible guesses.

Fix: Set strict_data_mode: true → Agent only uses actual data, never infers.

2. Performance Variability

Problem: Same agent request took 300ms sometimes, 2000ms other times.

Root cause:

LLM inference time varies
Data 360 query performance depends on cache hits
Network latency to external APIs

Fix: Implement timeout and retry logic. Cache frequent queries.

3. Version Management

Problem: Updated agent logic broke existing workflows.

Root cause: No rollback mechanism initially.

Fix: Salesforce added version pinning. Can deploy v1.2.0 but keep v1.1.0 active as fallback.

4. Testing Coverage

Problem: Hard to test all edge cases (infinite input combinations).

Fix:

Start with happy path tests
Add error cases as you discover them
Use production logs to generate new test cases

Developer Resources from Dreamforce

Trailhead modules (free training):

“Build Your First Agentforce Agent” (2 hours)
“Agentforce SDK for Developers” (3 hours)
“Multi-Agent Workflows” (4 hours)

GitHub repos:

Salesforce samples: github.com/salesforce/agentforce-examples
Community agents: github.com/agentforce-community/agents

Developer forums:

Salesforce Developers: developer.salesforce.com/forums
Stack Overflow: stackoverflow.com/questions/tagged/agentforce

My Recommendations for Developers

1. Start with Agent Builder (no-code) for prototypes, move to SDK for production.

2. Version control everything - treat agents as code.

3. Implement comprehensive logging - you’ll need it for debugging.

4. Test in sandbox extensively - agents can make expensive mistakes.

5. Monitor token usage - LLM costs add up quickly.

6. Contribute to community - share your agents, learn from others.

From a developer experience perspective, Agentforce is well-designed. The SDK is clean, documentation is good, and the tooling is getting better quickly.

Maya Patel
Senior Engineer @ TianPan

Code examples: https://github.com/salesforce/agentforce-examples
SDK docs: https://developer.salesforce.com/docs/agentforce/sdk
Trailhead: https://trailhead.salesforce.com/agentforce

vp_eng_keisha · October 21, 2025, 5:30am

Michelle, this is exactly the strategic conversation we need to have. I attended the “CTO Executive Roundtable” at Dreamforce where we discussed Agentforce adoption with VPs from OpenTable, Peloton, and Shopify. Let me add the executive engineering perspective.

The Leadership Challenge: Innovation Theatre vs Real Transformation

Every vendor promises “AI transformation” but Agentforce 360 raises the stakes by introducing autonomous agents into production systems. As VP of Engineering, my concerns aren’t about the technology - it’s about organizational readiness.

From the Dreamforce executive session, only 23% of companies experimenting with Agentforce have deployed agents to production. The other 77% are stuck in pilot purgatory. Why?

The gap isn’t technical - it’s organizational:

Decision-making authority (who approves agent actions?)
Accountability frameworks (who’s responsible when agents fail?)
Change management at scale (retraining 500+ employees)
Cross-functional alignment (engineering, legal, compliance, security must move together)

Multi-Agent Orchestration: The Real Architecture Challenge

The Dreamforce “Agent Orchestration” workshop showed Williams-Sonoma’s implementation: 17 agents working together for order fulfillment:

Customer Query → Triage Agent
                   ↓
         ┌─────────┴─────────┐
         ↓                   ↓
    Order Agent         Product Agent
         ↓                   ↓
    Inventory Agent     Pricing Agent
         ↓                   ↓
    Shipping Agent      Recommendation Agent
         ↓
    Notification Agent

The coordination complexity is exponential.

Each agent handoff introduces:

Latency (200-500ms per hop)
Error propagation risk (one failure cascades)
Context loss (information degraded in translation)
Debugging nightmares (which agent caused the issue?)

Williams-Sonoma shared they spent 6 months on orchestration logic alone - longer than building individual agents.

The Build vs Buy Decision

Pre-Dreamforce, we were evaluating:

Build custom: LangChain + OpenAI + custom orchestration
Buy Agentforce 360: Salesforce’s platform
Hybrid: Agentforce for CRM, custom for specialized needs

TCO Analysis (3-year horizon, our scale: 800 employees):

Build Custom

Year 1: $1.2M (4 engineers × 9 months, infrastructure, OpenAI API)
Year 2-3: $800K/year (2 engineers maintenance, hosting, API costs)
Total: $2.8M
Risk: High (custom orchestration, security, governance from scratch)

Buy Agentforce 360

Year 1: $420K (licenses + integration: 2 engineers × 4 months)
Year 2-3: $350K/year (licenses only, minimal maintenance)
Total: $1.12M
Risk: Medium (vendor lock-in, but pre-built governance)

Hybrid Approach

Year 1: $650K (Agentforce base + custom specialized agents)
Year 2-3: $480K/year
Total: $1.61M
Risk: Medium-High (integration complexity)

Decision: We’re going with Agentforce 360 + selective custom agents. The governance and orchestration frameworks alone save us 6+ months.

Workflow Automation vs Agent Orchestration

Critical distinction from the Dreamforce “Agent Architecture” session:

Traditional Workflow (deterministic):

IF order_value > $1000 THEN
  require_manager_approval()
ELSE
  auto_approve()
END

Agent Orchestration (probabilistic):

Agent analyzes order context:
- Customer history
- Product type
- Risk signals
- Current inventory
- Seasonal patterns

Agent DECIDES whether approval needed (not rule-based)

This is fundamentally different. We’re delegating judgment not just execution.

The VP from Shopify said it best: “We’re moving from ‘if-then’ to ‘ask AI’ and that requires a completely different trust model.”

Error Handling and Observability

Alex mentioned monitoring - let me make this concrete. We’re implementing:

1. Agent Execution Tracing

{
  "trace_id": "order_2847_agent_chain",
  "agents_invoked": [
    {"agent": "triage", "latency_ms": 340, "confidence": 0.94, "decision": "route_to_order_agent"},
    {"agent": "order_lookup", "latency_ms": 180, "confidence": 0.99, "result": "found"},
    {"agent": "inventory_check", "latency_ms": 520, "confidence": 0.87, "result": "low_stock"}
  ],
  "total_latency_ms": 1040,
  "final_outcome": "success",
  "human_intervention": false
}

Every agent in the chain is logged with confidence scores and decisions.

2. Confidence Thresholds

Agent Confidence < 0.85 → Escalate to human
Agent Confidence 0.85-0.95 → Execute with human review
Agent Confidence > 0.95 → Full autonomy

We’re starting conservative (0.90+ for autonomy) and adjusting based on accuracy data.

3. Circuit Breakers

if agent_error_rate > 5% in last_hour:
    disable_agent()
    alert_engineering_team()
    fallback_to_human_workflow()

Agents can fail gracefully without bringing down the entire system.

4. A/B Testing for Agents

50% of customer queries → Agent workflow
50% of customer queries → Traditional workflow

Measure:
- Resolution time
- Customer satisfaction
- Error rate
- Cost per resolution

Dreamforce emphasized this: treat agents like product features, not infrastructure. Test, measure, iterate.

The Accountability Framework

This is where most organizations fail. From the Dreamforce legal/compliance workshop:

Traditional Software:

Engineer writes code
QA tests code
Product approves release
Engineer is accountable for bugs

AI Agents:

Engineer configures agent
Agent makes runtime decisions
Who’s accountable when agent approves a fraudulent transaction?

We’re implementing a tiered accountability model:

Tier 1: Low-Risk Actions (Agent fully autonomous)

Answering FAQ questions
Scheduling meetings
Generating reports
Data lookups

Accountability: Engineering team (for system reliability)

Tier 2: Medium-Risk Actions (Agent proposes, human approves)

Discount approvals up to $500
Customer refunds under $200
Resource allocation recommendations

Accountability: Approving human (agent is advisory only)

Tier 3: High-Risk Actions (Always human-in-the-loop)

Contract negotiations
Pricing strategy changes
Security incident response
Legal compliance decisions

Accountability: Designated human decision-maker

This framework was validated by Salesforce’s legal team and aligns with emerging AI governance standards.

ROI: What We’re Actually Measuring

Finance_carlos will have more to say on this, but from an engineering leadership perspective:

Don’t measure AI ROI like software ROI.

Traditional software:

Fixed cost (development)
Predictable value (features delivered)

AI agents:

Ongoing cost (tokens, compute, fine-tuning)
Variable value (depends on agent performance)

Our metrics:

Efficiency Gains

Customer support resolution time: Target 40% reduction (from 18 min to 11 min)
Sales lead qualification: Target 60% time savings (from 30 min to 12 min per lead)
Employee onboarding: Target 50% faster access to information

Quality Improvements

Customer satisfaction (CSAT): Target +15 points
First-contact resolution rate: Target +25%
Employee productivity self-reported: Target +20%

Cost Optimization

Support tickets deflected: Target 30% (saves $340K/year in support costs)
Sales cycle shortened: Target 15% (increases revenue capacity)
Engineering hours saved on internal tools: Target 800 hours/year

Payback period target: 14 months (aggressive but achievable based on Dreamforce case studies)

Migration Strategy: Crawl, Walk, Run

We’re not doing a “big bang” rollout. Learned this from Peloton’s VP at Dreamforce:

Q1 2026: Crawl (Pilot)

Scope: Customer support FAQ agent (low-risk, high-volume)
Users: 25 support reps
Goal: Learn Agentforce, build confidence, iterate on governance
Success: 80% of FAQ queries handled by agent, CSAT maintained

Q2 2026: Walk (Expand)

Scope: Sales lead qualification, order status agents
Users: 80 support reps + 40 sales reps
Goal: Multi-agent orchestration, integrate with Slack
Success: 40% reduction in support resolution time, 25% faster lead qualification

Q3 2026: Run (Scale)

Scope: Full Agentforce 360, custom agents for engineering
Users: All 800 employees
Goal: “Agentic Enterprise” - agents embedded in all workflows
Success: Measurable productivity gains across all departments

Critical: Each phase has hard go/no-go criteria. If Q1 pilot doesn’t hit targets, we pause and reassess.

Integration with Existing Tech Stack

Priya mentioned security integration - let me add the engineering infrastructure view:

Our current stack:

CRM: Salesforce Sales Cloud
Support: Zendesk (will migrate to Service Cloud)
Data warehouse: Snowflake
Observability: Datadog
Auth: Okta SSO

Agentforce integration points:

Agentforce 360
    ↓
Data 360 (unified data layer)
    ↓
MuleSoft Integration Layer
    ↓ ↓ ↓
Salesforce  Snowflake  Zendesk  Custom APIs
    ↓
Okta (SSO + RBAC)
    ↓
Datadog (observability)

MuleSoft is the key: all agent data access goes through integration layer with:

Rate limiting (prevent agent runaway queries)
Audit logging (every data access tracked)
Permission checks (agent inherits user permissions)
Circuit breakers (failover to human workflows)

Integration effort: 4 engineers × 3 months = 12 person-months (matches Williams-Sonoma’s timeline)

The Question No One Asks: What If We Don’t Adopt?

Dreamforce had a sobering “Future of Work” panel. The consensus:

AI agents will become table stakes within 24 months.

Companies delaying adoption will face:

Competitive disadvantage (slower customer service, higher costs)
Talent challenges (engineers want to work with modern AI tools)
Customer expectations (users will expect AI-assisted experiences)

This isn’t optional. The question isn’t “should we adopt Agentforce?” but “how fast can we adopt responsibly?”

My Recommendation to the Team

Start now, start small: Q1 2026 pilot with customer support
Invest in governance: Accountability frameworks, observability, error handling
Measure rigorously: A/B testing, hard success metrics, go/no-go criteria
Build expertise: Send 10 engineers to Agentforce Builder training
Partner with Salesforce: Premium support for first 12 months
Plan for failure: Circuit breakers, human fallbacks, incident response

This is a multi-year transformation, not a quarter-long project. We need executive sponsorship, cross-functional alignment, and patient capital.

Question for the group: How are you thinking about agent governance in your organizations? Are you creating new roles (e.g., “Agent Product Manager”) or folding this into existing teams?

Looking forward to Carlos’s financial analysis and hearing from others on their Agentforce strategies.

finance_carlos · October 21, 2025, 5:30am

Keisha, excellent breakdown of the engineering economics. Let me add the CFO-level financial perspective since I attended the “AI ROI for Finance Leaders” session at Dreamforce.

The ROI Reality Check

Every vendor at Dreamforce promised “10x productivity gains” and “90% cost savings.” Let me give you the actual numbers from companies 12+ months into Agentforce deployments.

Real-World ROI Data (Dreamforce Case Studies)

FedEx (18 months with Agentforce, 15,000+ users):

Investment: $4.2M (Year 1), $2.8M/year (ongoing)
Savings: $12.1M/year (customer service efficiency, logistics optimization)
Net ROI: 188% (Year 2)
Payback period: 9 months

PepsiCo (14 months, 8,000 users):

Investment: $2.7M (Year 1), $1.9M/year (ongoing)
Savings: $7.3M/year (sales cycle reduction, support automation)
Net ROI: 171% (Year 2)
Payback period: 11 months

Williams-Sonoma (12 months, 6,200 users):

Investment: $1.8M (Year 1), $1.4M/year (ongoing)
Savings: $4.9M/year (order processing, inventory management)
Net ROI: 172% (Year 2)
Payback period: 10 months

Pattern: All three hit 9-11 month payback and 170-190% ROI in Year 2.

But here’s the critical detail they didn’t highlight on the main stage: Year 1 was breakeven or slightly negative for all three. The ROI comes in Year 2+ as agents mature.

Total Cost of Ownership (TCO) - The Complete Picture

Let me break down what Agentforce 360 actually costs at our scale (800 employees):

Year 1 Costs

1. Licensing ($252,000)

Agentforce 360 License: $150/user/month for 200 users (phased rollout)
  = $150 × 200 × 12 = $360,000

Enterprise discount (30% for multi-year commit) = -$108,000
Net licensing: $252,000

2. Implementation Services ($180,000)

Salesforce Professional Services: 3 months × $60K/month = $180,000
  - Agent configuration and customization
  - Data 360 integration
  - Training and change management
  - Go-live support

3. Internal Engineering ($240,000)

4 engineers × 3 months @ $200K fully-loaded = $200,000
QA/Testing resources: $40,000
Total: $240,000

4. Infrastructure & Integrations ($85,000)

MuleSoft integration layer: $35,000 (setup + annual)
Datadog observability expansion: $18,000/year
Additional Salesforce Storage: $12,000/year
API costs (OpenAI for custom agents): $20,000/year
Total: $85,000

5. Training & Change Management ($65,000)

Agentforce Builder training (10 engineers): $25,000
User training (200 users): $30,000
Change management consultant: $10,000
Total: $65,000

Total Year 1: $822,000

Year 2-3 Costs (Steady State, 800 users)

Licensing ($720,000/year)

$150/user/month × 800 users × 70% (enterprise discount) = $720,000/year

Ongoing Engineering ($120,000/year)

1 engineer dedicated to agent optimization: $100,000
QA/testing: $20,000
Total: $120,000

Infrastructure ($105,000/year)

MuleSoft: $45,000/year
Datadog: $25,000/year
Storage: $15,000/year
API costs: $20,000/year
Total: $105,000

Total Year 2-3: $945,000/year

3-Year TCO: $822K + $945K + $945K = $2,712,000

Expected Benefits (The Revenue Side)

Now here’s where it gets interesting. Based on Dreamforce benchmarks and our business:

Customer Support Efficiency

Current state:

12 support reps @ $65K fully-loaded = $780,000/year
Average resolution time: 18 minutes
45,000 tickets/year
Cost per ticket: $17.33

With Agentforce (30% deflection rate):

13,500 tickets handled by agents (no human touch)
31,500 tickets by humans (but faster - 11 min avg)
Reduction: 3-4 reps no longer needed = $240,000/year savings
OR same headcount handles 60% more volume (revenue enablement)

Conservative savings: $200,000/year

Sales Efficiency

Current state:

40 sales reps @ $150K fully-loaded = $6,000,000/year
Lead qualification: 30 min/lead
8,000 leads/year → 4,000 hours of manual qualification
Conversion rate: 12%

With Agentforce (60% faster qualification):

Lead qualification: 12 min/lead (agent pre-qualifies)
Reps spend 2,400 fewer hours on qualification
2,400 hours redirected to closing deals
At $500/hour revenue productivity = $1,200,000 additional revenue

Conservative value: $400,000/year (incremental margin)

Employee Productivity (Slack Agentic OS)

Current state:

800 employees spend avg 45 min/day searching for information
800 × 45 min × 240 work days = 144,000 hours/year
At $75/hour average fully-loaded cost = $10,800,000 in search time

With Slack Enterprise Search (30% time savings):

43,200 hours saved
At $75/hour = $3,240,000/year in productivity recapture

Conservative value: $600,000/year (assuming only 20% is truly recapturable)

Onboarding Acceleration

Current state:

120 new hires/year
90 days to full productivity
Onboarding cost: $15,000/employee = $1,800,000/year

With Channel Expert + Knowledge Agents:

60 days to full productivity (33% faster)
Saves 30 days × 120 employees = 3,600 days
At $400/day productivity = $1,440,000/year value

Conservative value: $180,000/year (partial productivity recapture)

Total Annual Benefits

Customer Support Savings:      $200,000
Sales Efficiency Gains:        $400,000
Employee Productivity:         $600,000
Onboarding Acceleration:       $180,000
──────────────────────────────
TOTAL ANNUAL BENEFIT:        $1,380,000/year

ROI Calculation

3-Year Financial Analysis:

Year 1:
  Cost: $822,000
  Benefit: $690,000 (50% of full benefit during rollout)
  Net: -$132,000 (investment year)

Year 2:
  Cost: $945,000
  Benefit: $1,380,000 (full run-rate)
  Net: +$435,000

Year 3:
  Cost: $945,000
  Benefit: $1,380,000
  Net: +$435,000

3-Year Total:
  Total Cost: $2,712,000
  Total Benefit: $3,450,000
  Net Benefit: $738,000
  ROI: 27%
  Payback Period: 16 months

This is conservative. I’m not including:

Competitive advantage (faster customer service)
Employee satisfaction (better tools)
Customer retention improvements
Innovation velocity (agents enable new products)

If we capture even 50% more value than modeled, ROI jumps to 65% over 3 years.

The Build vs Buy Economics (Revisited)

Keisha mentioned $2.8M TCO for custom build. Let me detail why that’s actually underestimated:

Custom Build Hidden Costs

Engineering Opportunity Cost:

4 engineers × 9 months = 36 person-months
Those engineers could build revenue-generating features instead
Opportunity cost: $500K-$1M in foregone product development

Security & Compliance:

SOC 2 audit for custom AI system: $80K-$150K
GDPR compliance review: $40K-$60K
Ongoing penetration testing: $30K/year
Total: $200K+

Model Training & Fine-Tuning:

Data labeling for custom agents: $50K-$100K
GPU compute for fine-tuning: $20K-$40K
Ongoing model updates: $30K/year
Total: $150K+

Operational Overhead:

24/7 on-call for AI systems: 2 engineers × $120K = $240K/year
Incident management and debugging: $80K/year
Total: $320K/year

Realistic custom build TCO: $4.2M over 3 years

Agentforce 360 at $2.7M is 35% cheaper AND carries less execution risk.

Risk-Adjusted ROI

As CFO, I need to account for execution risk:

Agentforce 360 Risk Factors:

✓ Vendor lock-in (Medium risk - mitigated by bring-your-own-LLM)
✓ Adoption challenges (Medium risk - mitigated by change management)
✓ Integration complexity (Low risk - Salesforce native)
✓ Performance issues (Low risk - proven at scale)

Probability-weighted ROI: 22% (applying 20% risk discount to base 27% ROI)

Custom Build Risk Factors:

✗ Technical execution (High risk - complex orchestration)
✗ Timeline overrun (High risk - 9 months likely becomes 15+)
✗ Cost overrun (High risk - custom AI projects run 2x over budget)
✗ Ongoing maintenance (High risk - expertise retention)

Probability-weighted ROI: -15% (50% chance of outright failure)

Decision: Agentforce 360 is the financially rational choice.

Cash Flow Implications

One thing Dreamforce didn’t discuss: cash flow.

Agentforce 360 Cash Flow:

Q1 2026: -$300K (licenses + services start)
Q2 2026: -$250K (ongoing licenses + engineering)
Q3 2026: -$150K (benefits starting to accrue)
Q4 2026: -$100K (approaching breakeven)

Q1 2027: +$50K (net positive)
Q2 2027: +$108K (benefits accelerating)
Q3 2027: +$108K
Q4 2027: +$108K

We need $800K cash outlay in Year 1 before seeing returns.

For our balance sheet, this is manageable. But for smaller companies, this could be a blocker.

Budget Allocation Framework

I recommend we structure this as:

40% OpEx (ongoing licenses, infrastructure)

Comes from IT budget
Predictable annual cost

60% CapEx (implementation, engineering, training)

Amortize over 3 years
Innovation budget allocation

This gives us:

Tax advantages (CapEx depreciation)
Budget flexibility (spread investment)
Executive clarity (strategic vs operational spend)

Measurement & Accountability

We’re tracking 6 KPIs monthly:

Agent Adoption Rate (% of users actively using agents)
- Target: 60% by Month 6
Agent Success Rate (% of queries successfully resolved)
- Target: 85% by Month 3
Support Ticket Deflection (% handled without human)
- Target: 30% by Month 9
Sales Cycle Time (days from lead to close)
- Target: -15% reduction by Month 6
Employee Time Saved (hours/week saved per employee)
- Target: 2.3 hours/week by Month 9
Customer Satisfaction (CSAT score)
- Target: Maintain current 4.2/5.0 (minimum)

If we’re not hitting 4 out of 6 KPIs by Month 9, we re-evaluate the investment.

The Non-Financial Case

Here’s the part that doesn’t show up in spreadsheets:

Talent Attraction:
Engineers want to work with cutting-edge AI. Agentforce adoption signals we’re a modern, forward-thinking company.

Competitive Positioning:
If our competitors deploy AI agents first, they’ll have faster response times, lower costs, better customer experience. We can’t afford to be 24 months behind.

Strategic Optionality:
Learning Agentforce now positions us for future AI innovations. The organizational knowledge compounds.

These aren’t measurable in Year 1-3 ROI, but they’re strategically critical.

My Recommendation

Approve the $822K Year 1 investment with strict governance:

✓ Hard KPI targets (must hit 4/6 by Month 9)
✓ Phased rollout (200 users → 800 users)
✓ Monthly CFO review (budget vs actuals)
✓ Go/no-go decision point at Month 6
✓ Executive sponsor accountability (Keisha owns this)

Expected outcome:

16-month payback
27% 3-year ROI
Strategic positioning for AI-first future

Risk: If execution fails, we lose $400-600K and 9 months. Acceptable given upside.

Question for the group: How are you structuring AI investments financially? Are you treating agents as R&D, product investment, or operational improvement?

Happy to share the detailed financial model offline if anyone wants to pressure-test the assumptions.