The CRM That Wants to Be Your Entire AI Strategy
Salesforce has never been shy about ambition. When they launched Agentforce in October 2024, the pitch was bold: autonomous AI agents that handle customer service, qualify leads, coach sales reps, and optimize campaigns — all running natively inside Salesforce with enterprise trust built in.
12,000 customers later, the pitch has mostly landed. Agentforce is a real product. The Einstein Trust Layer — data masking before LLM calls, zero data retention with providers, toxicity detection — is genuinely well-designed. The pre-built agents for service deflection, SDR automation, and sales coaching save months of development for common CRM workflows. If your entire world is Salesforce, Agentforce is a serious tool.
But your entire world isn't Salesforce.
Your financial data lives in an ERP. Your contracts live in a document management system. Your product data lives in a PostgreSQL database. Your operational metrics live in a data warehouse. Your vendor information lives across three systems that don't talk to each other. The questions your team actually needs answered — "Why did operating costs spike 15% versus forecast?" or "Which vendor contracts are up for renewal and how does their performance compare to alternatives?" — require reasoning across all of these sources, not just the CRM.
Agentforce is an AI agent platform built for Salesforce. Thallus is an AI agent platform built for your data — wherever it lives.
What Agentforce Is
Agentforce is Salesforce's AI agent platform, built on top of the Salesforce ecosystem. The architecture has four layers:
Atlas Reasoning Engine — the core AI that powers every agent. Uses deliberative reasoning with graph-based workflows. Breaks prompts into subtasks, evaluates each step, and proposes execution plans. Supports cooperative agent swarm capabilities for multi-agent coordination.
Agent configuration via five attributes: Role (what the agent does), Data (what it can access), Actions (what operations it can perform), Guardrails (boundaries it operates within), and Channel (where it's deployed — web chat, Slack, phone, messaging apps).
Actions built from Salesforce primitives — Flows, Apex code, MuleSoft API calls, and Prompt Templates. Agents choose which actions to invoke based on conversation context and their configured topics.
Einstein Trust Layer — wraps all LLM calls with data masking, zero data retention, toxicity detection, and dynamic grounding in customer data. This is the security layer, and it's real.
Salesforce also provides pre-built agents for common use cases: Service Agent for customer support deflection, SDR Agent for lead qualification and meeting scheduling, Sales Coach for rep training, Campaign Optimizer for marketing automation, and several others.
The platform has evolved rapidly — from chat-only reactive agents (1.0) to proactive background agents (2dx) to a unified builder with voice capabilities and Agent Script (360). The iteration speed is genuine.
What Agentforce Does Well
Credit where it's due — Agentforce gets several things right that matter for enterprise adoption.
The Trust Layer is real. PII is masked before it reaches any LLM provider. Providers retain zero customer data. Toxicity detection blocks harmful content. Dynamic grounding ensures responses come from your actual data, not model hallucinations. For organizations that need to prove their AI isn't leaking customer data to third parties, this is a meaningful capability.
Pre-built agents save real time. If you need a customer service deflection agent that works with Salesforce Cases, Knowledge, and Service Cloud — the Service Agent works out of the box. Reddit reported 46% case deflection and 84% reduction in resolution time. For CRM-specific use cases, the time-to-value is fast.
Deep CRM integration. Agents operate within Salesforce's permission model — field-level security, object-level security, sharing rules. An agent can only see what the user it's acting on behalf of can see. This isn't bolted-on access control; it's inherited from a mature platform.
Enterprise channels. Deploy agents across web chat, Slack, messaging apps (WhatsApp, SMS), phone (Agentforce Voice), and self-service portals. Omnichannel deployment from a single configuration.
The Walled Garden Problem
Everything Agentforce does well, it does within Salesforce's walls. The moment your question requires data that doesn't live in Salesforce, the architecture starts working against you.
Your Data Doesn't All Live in Salesforce
Agentforce agents natively access Salesforce objects via SOQL — Salesforce's proprietary query language. They can read Accounts, Contacts, Opportunities, Cases, and custom objects. They can query Data Cloud unified profiles. For CRM data, this works.
For everything else, you need MuleSoft.
Want your agent to check order status in NetSuite? MuleSoft connector. Want it to query your PostgreSQL data warehouse? MuleSoft connector. Want it to look up employee records in your HRIS? MuleSoft connector. Every non-Salesforce data source requires a pre-configured integration through MuleSoft's Anypoint Platform — which is a separate product, with separate licensing, requiring separate expertise to configure and maintain.
There's no concept of connecting a database and having agents discover its structure. No automatic schema discovery. No relationship inference across tables. No ad hoc SQL queries against external databases. The agent can only access external data through pre-built integration pipes that someone configured in advance.
Thallus connects directly to your databases — PostgreSQL, MySQL, MongoDB, and others. When you connect a database, the system discovers schemas automatically: tables, columns, types, foreign keys, implicit join paths. Agents generate SQL queries dynamically based on the question. No pre-configured integration pipes. No middleware. No separate product license.
The difference: Agentforce agents access external data through a pipeline someone built for them. Thallus agents discover and query your data directly.
No Cross-Source Reasoning
This is the architectural limitation that matters most.
When a Thallus agent queries your financial database and discovers an unusual vendor charge, the system can add steps to search your contract documents for that vendor's terms, check the procurement database for purchase order history, and synthesize all of it into a single analysis with citations. The planner creates these steps dynamically. The shared board carries structured findings between agents. Each agent builds on what previous agents discovered.
Agentforce agents reason within Salesforce data. They can access external data through MuleSoft, but the reasoning happens within the scope of their configured topics and actions — and each topic is limited to 15 actions. Cross-source analysis that spans your CRM, your ERP, your document management system, and your data warehouse isn't what the architecture was built for. It was built for CRM workflows that occasionally reference external data.
"Compare vendor spend from our financial database against contract terms from our document library and Salesforce opportunity data" is a natural Thallus question. In Agentforce, it's an integration project.
SOQL, Not SQL
Agentforce uses SOQL — Salesforce Object Query Language. It's designed for Salesforce objects, not general-purpose databases. Your analysts, data engineers, and BI team think in SQL. Your databases speak SQL. Agentforce speaks a proprietary query language that only works with Salesforce data structures.
Thallus generates standard SQL against your actual databases. The query language matches your data infrastructure, not a CRM vendor's proprietary format.
The Pricing Trap
Agentforce's pricing has been revised multiple times since launch — from $2/conversation to Flex Credits to per-user add-ons — and the current structure has five different models. Understanding what you'll actually pay requires careful analysis.
Five Pricing Models
Flex Credits (consumption): $0.10 per standard action, $0.15 per voice action. Sounds cheap until you do the math. A single agent interaction can involve multiple actions — each topic switch, each tool call, each data lookup is an action. A moderately complex customer service interaction might consume 5-10 actions ($0.50-$1.00). Scale that across thousands of daily interactions and the bill grows fast.
Per-conversation (legacy): $2 per conversation. A conversation ends when the customer leaves, escalates to a human, or 24 hours of inactivity pass. Still available but largely superseded.
Per-user add-on: $125/user/month for Sales/Service Cloud, $150/user/month for Industry Clouds. Unlimited internal agent usage — but only for that specific cloud product.
Agentforce 1 Editions: Starting at $550/user/month bundled with Flex Credits and Data 360 Credits.
Flex Agreements: Enterprise contracts that let you convert between user licenses and Flex Credits.
The Hidden Costs
The sticker price is the beginning, not the end.
Data Cloud is effectively mandatory. Agentforce's full capabilities require Data Cloud for unified customer profiles and grounding. Data Cloud has its own credit-based pricing. Users describe it as "fairly costly."
MuleSoft for external data. Every non-Salesforce data source needs MuleSoft connectors. MuleSoft is a separate product with separate licensing.
Token overages. Actions exceeding 10,000 tokens count as multiple actions. A complex query that generates 20,001 tokens is billed as three actions instead of one. Your finance team won't see this coming until the first invoice.
Slack licensing. Deploying agents in Slack requires Slack licenses — separate from Agentforce.
Implementation costs. Configuring the Atlas Reasoning Engine, building topics and actions, integrating data sources through MuleSoft — this requires specialized Salesforce admin and developer expertise.
What Thallus Costs
Thallus starts at $30/month. One investigation — which can involve multiple agents querying multiple databases, searching multiple document collections, and synthesizing a cited analysis — counts as one investigation. No per-action metering. No token overages. No mandatory middleware licensing.
Self-hosted Enterprise deployments remove the meter entirely. Unlimited investigations, unlimited users, no per-action charges. Your infrastructure, your data, your cost structure.
The Rigid Limits
Agentforce imposes hard limits that constrain what agents can do:
- 20 agents per organization. A large enterprise with dozens of departments and use cases hits this ceiling fast.
- 15 topics per agent. Each topic defines a job the agent can handle. 15 topics means 15 scoped responsibilities per agent.
- 15 actions per topic. Each action is an operation the agent can choose from. Complex workflows that need to query multiple systems, apply business rules, and take multiple actions hit this wall.
- 60-second action timeout. Any action that takes longer than 60 seconds fails. Complex database queries, document processing, or multi-step operations that exceed this are simply not possible.
- 65,536-token context window when data masking is enabled. For complex investigations with multiple data sources, this constrains how much context the agent can reason about.
Thallus has no agent cap per organization. The planner creates execution DAGs dynamically with as many steps as the question requires. Agent tool-use loops have configurable iteration limits, but the system's architecture — not a hard cap — determines how much work agents can do. Timeouts exist at workflow, branch, and node levels, configurable per deployment rather than fixed at 60 seconds.
The Model Lock-In
Agentforce's Atlas Reasoning Engine — the core AI that powers agent reasoning — uses Salesforce-managed models. You can choose between Salesforce's default model mix, Anthropic Claude on Bedrock, or Google Gemini. But these are Salesforce's choices, running on Salesforce's infrastructure.
For prompt templates and custom actions, model flexibility is broader — OpenAI, Anthropic, Google, Amazon Nova, and BYOLLM support for your own model instances on supported cloud providers. But the reasoning engine itself — the brain that decides what the agent does — runs Salesforce's models.
You cannot self-host models. You cannot connect models running on your own infrastructure. You cannot use Ollama or other local model providers. For organizations with air-gap requirements, data residency regulations, or a preference for running AI on their own hardware — this is a hard constraint.
Thallus is model-agnostic at every layer. The orchestrator, planner, agents, and synthesis all use whatever model provider you configure — OpenAI, Anthropic, Google, xAI, Mistral, OpenRouter, or local models through Ollama. BYOK means you use your own API keys with your own provider accounts. Self-hosted deployments with Ollama run fully air-gapped. No external model calls. No vendor choosing your reasoning engine.
No Self-Hosting
Agentforce is cloud-only. Your data flows through Salesforce's infrastructure. The Trust Layer ensures LLM providers don't retain it — but it still leaves your environment, passes through Salesforce's systems, and returns.
For organizations with data residency requirements — healthcare systems, financial institutions, defense contractors, legal firms — "the data is masked before it reaches the LLM" doesn't satisfy the requirement that data never leave the network.
Thallus deploys via Docker on your infrastructure. Combined with Ollama for local models, you run the entire platform air-gapped — agents, workflows, document processing, database queries — with zero external network calls. Same platform, same capabilities, same governance, whether you're on the SaaS or in a classified facility.
What Agentforce Can't Investigate
The differences converge on a fundamental architectural question: what can your AI agents actually figure out?
No Dynamic Planning
Agentforce agents work within predefined topics and actions. An agent has up to 15 topics, each with up to 15 actions. The agent reasons about which topic applies and which actions to invoke — but the universe of possibilities was defined by whoever configured the agent. Questions that fall outside the configured topics either get escalated to a human or answered with whatever the agent can cobble together from its limited action set.
Thallus plans at query time. The planner receives a question, evaluates connected data sources and available agents, and creates an execution DAG dynamically — steps with dependency edges, assigned to specialized agents, with independent steps parallelized automatically. The question determines the plan, not the other way around.
No Adaptive Re-Planning
Agentforce agents don't restructure their approach based on what they discover. They execute within their topic/action framework. If an action returns unexpected results, the agent can retry or escalate — but it can't decide it needs to query a data source that wasn't in its configured action set, or add investigation steps that nobody anticipated when the agent was built.
Thallus re-plans. After each execution batch, the evaluation loop decides: complete, add steps, or restructure. If the initial database query reveals an unexpected vendor charge, the evaluator adds steps to investigate that vendor — querying the procurement database, searching for the contract, checking the PO system. None of these steps were in the original plan. They emerged from the investigation.
No Cross-Source Synthesis With Citations
Agentforce responses are grounded in Salesforce data. The dynamic grounding feature ensures the agent references actual records rather than hallucinating. This is good for CRM queries.
Thallus synthesizes across every source in the investigation — databases, documents, integrations — with every claim traced back to its source section with citations. The synthesis agent doesn't just reference data; it correlates findings across sources, identifies patterns, and produces a unified analysis where the reader can verify every claim.
Three Reasoning Modes
Agentforce uses the Atlas Reasoning Engine for every interaction, applying the same deliberative reasoning approach regardless of question complexity.
Thallus auto-detects the appropriate reasoning mode:
ASK — single-agent response for straightforward questions. Fast, no planning overhead.
RESEARCH — planner-directed DAG execution with parallel steps, dependency management, and evaluation loops. For analytical questions spanning data sources.
INVESTIGATE — supervisor-driven reactive investigation pursuing multiple hypotheses based on emerging findings. For complex, open-ended questions.
"What's our revenue this quarter?" doesn't need the same reasoning approach as "Why did customer churn spike last month and what should we do about it?" The system matches strategy to question.
The Comparison
| Capability | Agentforce | Thallus |
|---|---|---|
| Data scope | Salesforce objects + external via MuleSoft | Any database directly + documents + integrations |
| Database access | SOQL for Salesforce; pre-configured MuleSoft pipes for external | Direct SQL with automatic schema discovery, PII detection, column-level controls |
| Document intelligence | Data Cloud knowledge connectors | Native pipeline — upload, chunk, embed, two-stage search, citations |
| Dynamic planning | Predefined topics/actions (15x15 cap) | AI planner creates DAGs at query time, re-plans based on results |
| Cross-source reasoning | CRM-centric with external lookups | Native — shared board context, parallel execution, cross-source synthesis |
| Model flexibility | Salesforce-managed reasoning engine; BYOLLM for prompts only | Fully model-agnostic + BYOK + local models via Ollama |
| Self-hosted | No — cloud only | Yes — Docker, air-gap capable with local models |
| Agent limits | 20 per org, 15 topics each, 15 actions each | No hard caps — planner scales dynamically |
| RBAC | Salesforce permission model (within SF ecosystem) | 4-tier at agent, tool, and data level across all sources |
| Audit trails | Trust Layer + Data 360 (requires Data Cloud) | Immutable with agent reasoning, PII redaction — included at every tier |
| Approval gates | Via Salesforce Flow integration | Native workflow node with multi-approval, timeouts, escalation |
| Workflow engine | Salesforce Flow (separate product) | Native DAG: 9 node types, scheduling, delivery, versioning, crash recovery |
| Pricing | $0.10/action or $2/conversation or $125-550/user/mo + Data Cloud + MuleSoft | From $30/mo — self-hosted Enterprise unlimited |
| Vendor lock-in | Deep — Salesforce + Data Cloud + MuleSoft + Slack | None — self-hosted or SaaS, any model provider, any database |
When You Need What
Use Agentforce when:
- Your organization is already deeply invested in the Salesforce ecosystem
- The primary use cases are CRM workflows — service deflection, lead qualification, sales coaching
- Your data largely lives in Salesforce and Data Cloud
- You've already licensed MuleSoft for external integrations
- Cloud-only deployment is acceptable
- You want pre-built agents for common CRM tasks with minimal configuration
Use Thallus when:
- Your data spans multiple systems — databases, document stores, and SaaS tools — not just a CRM
- You need agents that reason across all your data sources, not just one vendor's ecosystem
- You need dynamic planning that creates investigation strategies at query time instead of predefined topic/action configurations
- Enterprise governance needs to span all data sources, not just Salesforce objects
- Self-hosting, air-gap deployment, or data residency requirements exist
- Model flexibility matters — choose your own provider, bring your own keys, run local models
- You need workflows with versioning, crash recovery, AI-evaluated success criteria, and approval gates
- Non-technical users need to ask ad hoc questions across databases and documents without predefined agent configurations
- You'd rather pay a predictable monthly price than navigate five pricing models plus mandatory add-ons
The Bottom Line
Agentforce is a good AI agent platform for Salesforce. The Trust Layer is well-designed. The pre-built agents deliver real value for CRM use cases. The Atlas Reasoning Engine is a serious piece of technology. For organizations whose entire data universe lives in Salesforce, it's a capable tool.
But most organizations' data doesn't live in one place. The financial analysis that matters crosses the CRM, the ERP, the data warehouse, and the contract library. The vendor review that saves money requires querying procurement, finance, and document systems that Salesforce doesn't own. The operational investigation that prevents the next crisis needs to correlate data from systems that have nothing to do with customer relationships.
Agentforce answers questions about your CRM. Thallus answers questions about your business — wherever the data lives, with agents that plan dynamically, reason across sources, synthesize with citations, and run on your infrastructure if you need them to. No middleware licensing. No proprietary query languages. No 20-agent cap. No mandatory cloud vendor.
Your AI agents should go where your data goes. Not where your CRM vendor wants you to stay.