Doti Acquisition Guide for Salesforce | SalesforceTutorial

Doti is an agentic enterprise search company that Salesforce agreed to acquire in November 2025 and completed acquiring on December 1, 2025. For Salesforce admins, developers, and architects, the practical point is not a new setup checkbox today; it is Salesforce’s direction toward search that can understand enterprise context, work through Slack, and support Agentforce actions across trusted business data.

This guide explains what changed, what did not change, and how to prepare your Salesforce org for AI search patterns without assuming that every Doti capability is already exposed as a configurable Salesforce feature. For background on Agentforce architecture, see our Agentforce Salesforce guide and the Salesforce Developer documentation for the Agent API.

Doti: what Salesforce announced

Salesforce announced on November 13, 2025 that it had signed a definitive agreement to acquire Doti. Salesforce later added an editor’s note confirming that the acquisition closed on December 1, 2025. The official announcement says the Doti team will strengthen Salesforce’s AI research and development hub in Israel and help accelerate unified, agentic search and knowledge discovery for customers.

That wording matters. Salesforce did not describe Doti as a replacement for Salesforce Search, Slack search, Data Cloud, Knowledge, or Agentforce Data Libraries. It described Doti as talent and search expertise that can extend Salesforce’s platform direction. Treat the announcement as a roadmap signal, not a migration task.

Salesforce signs definitive agreement to acquire doti: what the phrase means

The search query salesforce signs definitive agreement to acquire doti refers to the legal stage Salesforce announced before the transaction closed. A definitive agreement means the parties signed transaction terms, but closing still depended on customary closing conditions. Because Salesforce later confirmed completion, admins should read the November announcement together with the December 1, 2025 editor’s note.

Salesforce acquires doti: close status and timing

The query salesforce acquires doti now points to a completed acquisition, not only a pending agreement. Salesforce’s announcement originally expected closing in the fourth quarter of Salesforce fiscal year 2026, and the later note confirms Doti joined Salesforce on December 1, 2025.

What does Doti change for Salesforce search?

Doti is relevant because enterprise search is no longer only a keyword box. In an Agentforce and Slack context, search needs to answer questions from CRM records, knowledge articles, files, Slack conversations, and connected systems while honoring permissions. That requires indexing, grounding, identity, source citations, and action controls.

For admins, the useful question is: Can a user or agent find the correct answer without exposing data the user should not see? The acquisition points to that problem space. It does not remove the need to configure sharing, field-level security, Knowledge visibility, Data 360, or Slack workspace governance.

How Doti fits with Slack and Agentforce

Salesforce’s announcement names Slack as the conversational interface for the search capability Salesforce wants to build. That aligns with current Agentforce guidance: Salesforce Help documents how to connect an Agentforce Employee agent to Slack, and Trailhead explains that agents in Slack can use both structured CRM data and unstructured conversation data when configured correctly.

In enterprise orgs, this changes the design conversation. A Slack-first agent is not just a chatbot. It is an access path to Salesforce data, knowledge, actions, and collaboration context. Your architecture review should include Slack workspace boundaries, channel naming, retention policies, who can install or discover agents, and whether agent responses should include sources.

Agentforce and Slack setup areas to review

• Agent channel: Confirm whether the agent is intended for Slack, Lightning Experience, mobile, or another supported channel.
• Agent purpose: Keep each agent’s topics narrow enough to test. A sales enablement agent and an HR policy agent should not share the same unrestricted action set.
• Actions: Review every Flow, Apex invocable method, prompt template, and external action exposed to the agent.
• Grounding data: Use Knowledge, files, Data Libraries, or other supported sources only after access rules are understood.
• Testing: Test expected answers, denied answers, ambiguous questions, and escalation paths before enabling broad Slack access.

For implementation details, start with Salesforce Help for connecting an agent to Slack and Trailhead’s module on Agentforce configuration for Slack deployment. For related admin patterns, see our Salesforce Slack integration guide.

How to prepare your org for agentic enterprise search

You cannot enable Doti from Setup as a standalone Salesforce feature. You can, however, prepare your org for the type of agentic search Salesforce is building. The work is mostly data governance, source design, and secure action design.

1. Clean the source data before adding agents

Agentic search fails when the source data conflicts with itself. Before a broad Agentforce rollout, identify the objects and sources an agent will use. For a service agent, that may include Case, Account, Contact, Entitlement, Knowledge, and Slack support channels. Remove stale articles, merge duplicate accounts, standardize picklist values, and document which fields should never appear in generated responses.

2. Review security before indexing or grounding

Salesforce security still starts with the data model. Organization-Wide Defaults control the baseline record access. Sharing rules, teams, territories, manual sharing, restriction rules, permission sets, and field-level security refine that access. Agentforce actions and search experiences must respect the running user’s context, so do not use system-mode shortcuts to feed answers unless your design has a documented reason and compensating controls.

3. Build answerable knowledge, not long pages

Knowledge articles should answer one question or one procedure clearly. If an article mixes pricing, legal terms, support steps, and implementation notes, an agent can retrieve a chunk that contains the wrong context. Use clear article titles, product metadata, data categories, and review dates. Where the feature supports it, enable source display so users can verify the answer.

4. Separate search from action

A search result tells the user what is known. An action changes data or sends a message. Keep these separate in your agent design. For example, allow an agent to summarize open cases before you allow it to create a refund request, update an opportunity, or send a Slack direct message. This separation makes testing and audit review easier.

Example: secure Agentforce action for customer context

The following Apex example is not an acquisition API. It shows the kind of governed Salesforce data access that matters when agentic search and Agentforce actions use CRM records. The class is bulkified, uses one Account query and one Case query, avoids SOQL inside loops, and uses WITH USER_MODE so object and field permissions are enforced by the query. Compile this example with a current API version such as v60.0 or later and adjust validation-rule requirements for your org.

public with sharing class CustomerContextAgentAction {
    public class Request {
        @InvocableVariable(
            label='Account Id'
            description='The Account record to summarize for the agent.'
            required=true
        )
        public Id accountId;
    }

    public class Response {
        @InvocableVariable(label='Account Id')
        public Id accountId;

        @InvocableVariable(label='Account Name')
        public String accountName;

        @InvocableVariable(label='Industry')
        public String industry;

        @InvocableVariable(label='Open Case Count')
        public Integer openCaseCount;

        @InvocableVariable(label='Recent Open Case Subjects')
        public String recentOpenCaseSubjects;

        @InvocableVariable(label='Message')
        public String message;
    }

    @InvocableMethod(
        label='Get Customer Context for Agent'
        description='Returns account and open case context for an Agentforce action.'
    )
    public static List<Response> getContext(List<Request> requests) {
        List<Response> results = new List<Response>();

        if (requests == null || requests.isEmpty()) {
            return results;
        }

        Set<Id> accountIds = new Set<Id>();
        for (Request requestItem : requests) {
            if (requestItem != null && requestItem.accountId != null) {
                accountIds.add(requestItem.accountId);
            }
        }

        if (accountIds.isEmpty()) {
            return results;
        }

        Map<Id, Account> accountsById;
        Map<Id, Integer> openCaseCountByAccountId = new Map<Id, Integer>();
        Map<Id, List<String>> caseSubjectsByAccountId = new Map<Id, List<String>>();

        try {
            accountsById = new Map<Id, Account>([
                SELECT Id, Name, Industry
                FROM Account
                WHERE Id IN :accountIds
                WITH USER_MODE
            ]);

            for (Case caseRecord : [
                SELECT AccountId, Subject
                FROM Case
                WHERE AccountId IN :accountIds
                AND IsClosed = false
                WITH USER_MODE
                ORDER BY CreatedDate DESC
                LIMIT 200
            ]) {
                Integer currentCount = openCaseCountByAccountId.containsKey(caseRecord.AccountId)
                    ? openCaseCountByAccountId.get(caseRecord.AccountId)
                    : 0;
                openCaseCountByAccountId.put(caseRecord.AccountId, currentCount + 1);

                if (!caseSubjectsByAccountId.containsKey(caseRecord.AccountId)) {
                    caseSubjectsByAccountId.put(caseRecord.AccountId, new List<String>());
                }

                List<String> subjects = caseSubjectsByAccountId.get(caseRecord.AccountId);
                if (subjects.size() < 5 && !String.isBlank(caseRecord.Subject)) {
                    subjects.add(caseRecord.Subject);
                }
            }
        } catch (QueryException queryAccessException) {
            for (Request requestItem : requests) {
                Response blocked = new Response();
                blocked.accountId = requestItem == null ? null : requestItem.accountId;
                blocked.openCaseCount = 0;
                blocked.message = 'The running user cannot access one or more fields required by this agent action.';
                results.add(blocked);
            }
            return results;
        }

        for (Request requestItem : requests) {
            Response responseItem = new Response();
            responseItem.accountId = requestItem == null ? null : requestItem.accountId;
            responseItem.openCaseCount = 0;

            if (requestItem == null || requestItem.accountId == null) {
                responseItem.message = 'No Account Id was provided.';
                results.add(responseItem);
                continue;
            }

            Account accountRecord = accountsById.get(requestItem.accountId);
            if (accountRecord == null) {
                responseItem.message = 'No accessible Account was found for the running user.';
                results.add(responseItem);
                continue;
            }

            responseItem.accountName = accountRecord.Name;
            responseItem.industry = accountRecord.Industry;
            responseItem.openCaseCount = openCaseCountByAccountId.containsKey(accountRecord.Id)
                ? openCaseCountByAccountId.get(accountRecord.Id)
                : 0;

            List<String> subjects = caseSubjectsByAccountId.get(accountRecord.Id);
            responseItem.recentOpenCaseSubjects = subjects == null
                ? ''
                : String.join(subjects, '; ');

            responseItem.message = 'Customer context returned successfully.';
            results.add(responseItem);
        }

        return results;
    }
}

Why this pattern matters for agentic search: the agent receives a small, permission-aware summary instead of unrestricted object data. The LIMIT 200 clause protects response size, but it is not a substitute for proper scoping. In a high-volume org, filter by account segment, entitlement, or a date window and add a second action for deeper case analysis.

Test class for the Agentforce Apex action

Salesforce requires Apex unit tests to pass and overall coverage to meet the production deployment threshold. This test covers the main success path. Add negative tests for users without access, missing input, validation rules, and custom required fields in your org.

@IsTest
private class CustomerContextAgentActionTest {
    @IsTest
    static void returnsAccountAndCaseContext() {
        Account accountRecord = new Account(
            Name = 'Acme Manufacturing',
            Industry = 'Manufacturing'
        );
        insert accountRecord;

        Case caseRecord = new Case(
            AccountId = accountRecord.Id,
            Subject = 'Shipment delay',
            Status = 'New',
            Origin = 'Phone'
        );
        insert caseRecord;

        CustomerContextAgentAction.Request requestItem =
            new CustomerContextAgentAction.Request();
        requestItem.accountId = accountRecord.Id;

        Test.startTest();
        List<CustomerContextAgentAction.Response> responses =
            CustomerContextAgentAction.getContext(
                new List<CustomerContextAgentAction.Request>{ requestItem }
            );
        Test.stopTest();

        System.assertEquals(1, responses.size(), 'One response should be returned.');
        System.assertEquals(accountRecord.Id, responses[0].accountId);
        System.assertEquals(1, responses[0].openCaseCount);
        System.assertEquals('Customer context returned successfully.', responses[0].message);
    }
}

To expose this method in Agentforce Builder, use Salesforce’s documented custom action pattern for Apex invocable methods. The Agentforce Apex invocable method documentation explains how the method becomes available as a custom action. The secure Apex guidance explains why with sharing and user-mode data access matter.

Salesforce acquires spindle ai definitive agreement: how it relates to Doti

The query salesforce acquires spindle ai definitive agreement appears near Doti searches because both announcements happened in November 2025 and both relate to Agentforce. They are not the same acquisition. Doti focuses on enterprise search and knowledge discovery. Spindle AI focuses on agentic analytics, scenario modeling, and Agentforce observability and self-improvement, according to Salesforce’s announcement.

Architecturally, the two moves point to different layers of the same AI platform problem. The search acquisition is about finding and grounding the right information. Spindle AI is about analyzing outcomes and improving agent behavior. If your roadmap includes Agentforce, Slack, Data Cloud, or analytics, track both announcements but design against generally available Salesforce features, not acquisition names.

Best practices for Salesforce teams tracking Doti

• Do not promise Doti features to users until Salesforce documents product availability. Acquisition announcements are not implementation guides.
• Use official release notes for feature readiness. Confirm whether a capability is Generally Available, Beta, or Pilot before adding it to a delivery plan.
• Keep search permissions boring. If a user cannot read a record, article, file, or Slack channel, the agent should not use that source in its answer.
• Build small actions. Prefer several narrow Agentforce actions over one method that reads many objects and decides everything in Apex.
• Measure answer quality. Capture failed questions, missing sources, latency, and escalation rates. Search relevance work does not end at deployment.
• Plan for audit. Document which sources ground each agent, which actions can mutate data, and which permission sets grant access.

Common errors with Doti and Salesforce acquisition planning

Assuming Doti is a Setup feature

The acquisition is not listed as a Setup toggle that admins can enable. Until Salesforce publishes product documentation for an acquisition-derived capability, use supported features such as Agentforce, Slack deployment options, Data Libraries, Salesforce Search, Knowledge, Flow, Apex actions, and the Agent API.

Ignoring unstructured data governance

Slack messages, files, and knowledge articles can contain customer data, pricing notes, legal advice, or internal incident details. Before connecting agents to these sources, decide which channels and repositories are in scope. Review retention, export, and access rules with your security team.

Letting agent actions bypass CRUD and FLS

Apex runs in system context unless you design for user access. For agent actions, use with sharing, WITH USER_MODE, or Security.stripInaccessible() where appropriate. Avoid returning fields only because the integration user can see them.

Testing only happy-path prompts

Test prompts that should fail. Ask for restricted account data, fields hidden by field-level security, stale policies, closed cases, and answers outside the agent’s topic. A Doti-style search experience is only useful if it refuses unsafe or unsupported answers.

Where to watch for product updates

Use Salesforce-owned sources for product signals. Start with the official acquisition announcement, the Salesforce Release Notes, Salesforce Help, and the Agentforce Developer Guide. For implementation topics around APIs and platform architecture, see our Salesforce API guide and Salesforce MCP overview.

For most teams, the next practical step is not to wait for a branded acquisition setting. Start by improving source quality, permission design, and Agentforce action boundaries. Those controls will still matter when Salesforce ships more search and Slack capabilities influenced by the acquisition.

Frequently Asked Questions