This guide is for Salesforce admins. By the end of it, every Zen Agent that runs on a Project can read the recent conversation from that Project's Slack channel alongside the Salesforce data it already sees. You will connect Slack once, then reuse the connection across as many agents as you like.

If you have not built a Context Source before, read Creating and Configuring Context Sources first. This article follows the same pattern and adds the steps needed to reach outside Salesforce.

Before you start, you need:

• The Precursive AI Admin permission set, so you can create API Providers and Context Sources
• Access to Flow Builder
• Permission to create and install an app in your Slack workspace (or a Slack admin who can do it for you)

A note on external data. Slack messages are written by people, so they sit outside Salesforce's sharing and field-level security. Precursive AI requires an admin to set up any external source deliberately, and you should only connect channels whose content you are comfortable sending to the AI. Review the security considerations in Creating and Configuring Context Sources and check with your compliance team if you are unsure.

How it fits together

There are nine steps. Each one is small, and you only do them once.

Step	What it does
1. Create the Slack app	Gives Precursive AI a bot token that can read channel history.
2. Store the token in an External Credential	Keeps the token encrypted in Salesforce and adds it to every request.
3. Grant users access to the credential	Lets the people who run Zen Agents use the token.
4. Create the Named Credential	Points the credential at https://slack.com and allows the Precursive package to use it.
5. Register the API Provider	Tells Precursive AI which Named Credential to use when a Flow says "call Slack".
6. Add a Slack Channel ID field to Project	Records which channel belongs to which Project.
7. Build the Context Source Flow	Looks up the Project, calls the Slack API using the Call External API action, and returns the messages.
8. Create the Context Source	Registers the Flow with Precursive AI so builders can add it to Zen Agents.
9. Add it to a Zen Agent and test	Confirms the Slack conversation reaches the AI.

Step 1: Create the Slack app

Precursive AI reads Slack as a bot. A bot only sees the channels it is a member of, so we also give it permission to join public channels on its own. Private channels need a one-off invite, covered below.

1. Go to api.slack.com/apps and select Create New App
2. Choose Blank app, name the app (for example Precursive AI) and pick your workspace
3. Open OAuth & Permissions and, under Bot Token Scopes, add:
   • channels:history - read messages in public channels
   • groups:history - read messages in private channels the bot has been invited to
   • channels:join - let the bot join public channels itself
   • channels:read - list channels, useful when testing the connection
4. Click Install to Workspace and authorise the app
5. Copy the Bot User OAuth Token. It starts with xoxb-. You will paste it into Salesforce in the next step, so keep it somewhere safe and do not share it.

What the bot can see. With channels:join, the Flow you build later joins the Project's public channel automatically the first time it runs. For a private channel, someone in that channel must invite the bot once by typing /invite @Precursive AI (or whatever you named the app). Until then, Slack returns not_in_channel and the agent sees no messages.

Alternative: a user token. If you would rather not manage channel membership, you can install the app with user scopes instead and use the User OAuth Token (xoxp-). The bot then sees everything that user can see, with no invites. The trade-off is that every agent, for every Salesforce user, reads Slack with that one person's visibility. If you choose this route, pick the account deliberately and treat the token as a shared service credential.

Step 2: Store the token in an External Credential

Salesforce keeps the token encrypted and adds it to each request as a header. You never put the token in a Flow or a field.

1. Go to Setup > Named Credentials > External Credentials tab
2. Click New and fill in:
   • Label: Slack
   • Name: Slack
   • Authentication Protocol: Custom
3. Save
4. Under Principals, click New and fill in:
   • Parameter Name: Slack
   • Sequence Number: 1
   • Identity Type: Named Principal
5. Under Authentication Parameters on that principal, select Add:
   • Name: Token
   • Value: paste the xoxb- token on its own, with no Bearer prefix
6. Save the principal, then back on the External Credential add a Custom Header:
   • Name: Authorization
   • Value: Bearer {!$Credential.Slack.Token}

Step 3: Grant users access to the credential

A Named Credential only works for users who have been granted its principal. That includes anyone who runs or schedules a Zen Agent, not just you.

1. Go to Setup > Permission Sets
2. Open your Precursive AI: MCP/API permission set. If it does not exist yet, create a new permission set with that name. It is the one place to keep principal access for every external connection Precursive AI uses.
3. Click External Credential Principal Access, then Edit
4. Move Slack - Slack to the Enabled list and save
5. Assign the permission set to every user who will run Zen Agents that use this Context Source

Step 4: Create the Named Credential

The Named Credential is the address. It pairs the Slack host with the External Credential you just created.

1. Go to Setup > Named Credentials > New
2. Fill in:
   • Label: Slack API
   • Name: Slack_API
   • URL: https://slack.com
   • Enabled for Callouts: On
   • External Credential: Slack
   • Generate Authorization Header: unchecked
   • Allow Formulas in HTTP Header: checked
   • Allowed Namespaces for Callouts: PSX
3. Save

Allow Formulas in HTTP Header must be on. Without it, Salesforce sends the text {!$Credential.Slack.Token} literally and Slack rejects every call with invalid_auth.

Allowed Namespaces for Callouts is essential. PSX is the Precursive package namespace. Without it, the Call External API action is not permitted to use this Named Credential and the Flow fails with an authorisation error. You do not need a Remote Site Setting; the Named Credential takes care of endpoint authorisation.

Step 5: Register the API Provider

The API Provider is how a Flow refers to Slack by name. It is a custom metadata record.

1. Go to Setup > Custom Metadata Types, find API Provider and click Manage Records
2. Click New and fill in:
   • Label: Slack
   • API Provider Name: Slack
   • Auth Type: Named Credential
   • Named Credential: Slack_API
   • Active: checked
   • Description: Slack Web API for reading project channel history
3. Save

Leave Base URL, Certificate Name, Service Account Email and Token Endpoint blank. They apply to service-account providers only.

Test the connection

1. Open Precursive AI Settings from the App Launcher or Precursive HQ
2. Go to the External Services tab, then the API Providers sub-tab
3. On the Slack card, click Test Connection
4. Enter /api/auth.test as the test endpoint path and run the test

A working connection returns a body that starts with {"ok":true and names your workspace and bot user. If ok is false, see Troubleshooting at the end of this article.

Step 6: Add a Slack Channel ID field to Project

The Flow needs to know which channel belongs to each Project. A simple text field does the job.

1. Go to Setup > Object Manager and open Project (API name preempt__PrecursiveProject__c)
2. Under Fields & Relationships, click New and choose Text
3. Fill in:
   • Field Label: Slack Channel ID
   • Length: 255
   • Field Name: Slack_Channel_ID (Salesforce saves it as Slack_Channel_ID__c)
4. Set field-level security so project managers can edit it, add it to the Project page layout and save

Finding a channel's ID in Slack. Open the channel, click its name at the top to open the channel details, and scroll to the bottom of the About tab. The Channel ID looks like C0123456789. Paste it into the new field on the Project.

If your org already links Projects to channels with Salesforce Channels for Records, the channel ID is also available on the standard SlackChannelRelatedRecord object, and you can read it from there instead of a custom field.

Step 7: Build the Context Source Flow

The Context Source Flow receives a Project ID from Precursive AI, reads the channel ID from the Project, asks Slack for recent messages, and hands the response back. Precursive AI always passes the record ID in a Text input variable named exactly recordId.

1. Go to Setup > Flows and click New Flow
2. Choose Autolaunched Flow (No Trigger) and click Create
3. Save it straight away with:
   • Flow Label: Precursive AI: Project Slack Channel History
   • Flow API Name: Precursive_AI_Project_Slack_Channel_History

Avoid a double underscore anywhere in your Flow API name. Precursive AI reads a double underscore as a namespace separator.

Resources

Create these from Toolbox > New Resource.

Resource	Type	Settings
recordId	Variable, Text	Available for input checked. The name is case-sensitive.
slackChannelHistory	Variable, Text	Available for output checked. This is what the AI receives.
slackAPIEndpoint	Formula, Text	"/api/conversations.history?channel=" & {!Get_Project.Slack_Channel_ID__c} & "&limit=50"
joinChannelBody	Text Template, view as plain text	{"channel":"{!Get_Project.Slack_Channel_ID__c}"}

Adjust limit to control how many messages the agent sees. Fifty recent messages is a good starting point. Fewer messages means a smaller, more focused context; Slack allows up to 1000.

Elements

Add these in order, connecting each to the next.

1. Get Records - label Get Project. Object Project, condition Id Equals {!recordId}, store only the first record, automatically store all fields.
2. Decision - label Has Slack Channel. Outcome Yes when {!Get_Project.Slack_Channel_ID__c} Is Null is False. Connect the default outcome straight to the end of the Flow so Projects without a channel return nothing rather than an error.
3. Action - search for Call External API, label it Join Channel. This lets the bot join a public channel it has not seen before.
   • Provider Name: Slack
   • Endpoint Path: /api/conversations.join
   • HTTP Method: POST
   • Request Body: {!joinChannelBody}
   Slack replies ok: true if the bot joined or was already a member. For private channels it replies with an error, which is fine: connect the element straight to the next step regardless of the result.
4. Action - Call External API again, label it Slack Conversation History.
   • Provider Name: Slack
   • Endpoint Path: {!slackAPIEndpoint}
   • HTTP Method: GET
   • Leave Impersonate User, OAuth Scope, Request Body and Request Headers JSON blank
5. Assignment - label Assign Results. Set {!slackChannelHistory} Equals {!Slack_Conversation_History.responseBody}.
6. Save, then Activate.

Provider Name must match the API Provider Name from Step 5 exactly. Endpoint Path is everything after https://slack.com, so it always starts with / and can include a query string.

Check it with Debug

1. Click Debug, enter the ID of a Project that has a Slack Channel ID, and run
2. Expand the Slack Conversation History step. Success should be true and Status Code 200
3. Look at Response Body. It should begin {"ok":true,"messages":[

The Call External API action never stops the Flow with a fault. If something is wrong it returns Success as false and explains why in Error Message. Slack has one extra habit: it returns Status Code 200 even when it cannot help, and puts the reason in the body as {"ok":false,"error":"..."}. Check both when debugging.

Step 8: Create the Context Source

The Context Source makes the Flow available to builders.

1. Open the App Launcher, search for Context Sources and click New
2. Fill in the fields:

Field	Value
Name	Project Slack
Source Object API Name	preempt__PrecursiveProject__c
Active	checked
Context Description	Recent chats from the Project Slack Channel. Describe what the data is, not how the AI should use it. Usage instructions belong on the Zen Agent.
Flow API Name	Precursive_AI_Project_Slack_Channel_History
Flow Output Variables	slackChannelHistory

3. Save

Step 9: Add it to a Zen Agent and test

1. Open a Zen Agent whose Source Object is Project, or create a test one
2. Add a Zen Agent Context Source and select Project Slack
3. In Instructions, tell the agent how to use the conversation. For example: Use the Slack conversation to identify decisions, blockers and open questions raised by the team that are not yet reflected in the project record.
4. Run Preview on a Project that has a Slack Channel ID
5. Open the Insight Result, download the context file and confirm the Project Slack entry contains the messages you expect

Once you are happy, the same Context Source can be added to any other Project agent without further setup.

Tips

• Keep the window recent. Add &oldest= with a Unix timestamp to the endpoint formula if you only want messages from, say, the last 14 days. Smaller contexts produce sharper insights and cost fewer tokens.
• Expect user IDs, not names. Slack messages carry the author as an ID such as U0123456789. The AI can still follow the conversation; if you need names, the users:read scope and a second call to /api/users.list can add them, at the cost of a longer Flow.
• Rotate the token in one place. If the Slack app is reinstalled or the token changes, update the Token parameter on the External Credential principal. Nothing else needs to change.
• Reuse the connection. The Slack API Provider is not tied to Projects. The same provider can back other Context Sources, for example an Account channel or a customer support channel, each with its own Flow.

Troubleshooting

What you see	What to check
API provider not found: Slack	The Provider Name in the Flow does not match the API Provider Name on the custom metadata record. Both are case-sensitive.
API provider is inactive: Slack	Tick Active on the API Provider record.
Endpoint path must start with "/"	The endpoint formula is missing its leading slash, or you pasted a full URL. Only the path after https://slack.com goes in Endpoint Path.
Unauthorized endpoint or another callout authorisation error	Check Allowed Namespaces for Callouts is PSX on the Named Credential, and that the running user has Slack - Slack enabled under External Credential Principal Access.
{"ok":false,"error":"invalid_auth"}	The token was pasted with a Bearer prefix, Allow Formulas in HTTP Header is unchecked, or the token has been revoked. Reinstall the Slack app to issue a new one.
{"ok":false,"error":"not_in_channel"}	The bot is not a member of the channel. For public channels, confirm the channels:join scope and the Join Channel step. For private channels, invite the bot with /invite.
{"ok":false,"error":"missing_scope"}	A scope was added after the app was installed. Click Reinstall to Workspace in the Slack app settings, then update the token in the External Credential.
{"ok":false,"error":"channel_not_found"}	The Slack Channel ID on the Project is wrong or belongs to a different workspace.
Agent runs but the Slack context is empty	Confirm the Flow is Active, that Flow Output Variables on the Context Source reads exactly slackChannelHistory, and that the Project has a Slack Channel ID.