Agentforce Coworker AI Skills: who teaches the agent, and who governs it

There are now three different things Salesforce calls a “skill,” and a lot of admins are about to conflate them. This post is about the newest one, and the reason it’s worth getting precise: it hands the ability to teach an agent to people who don’t build agents.

At the September 11, 2026 launch of its job-ready agents, Salesforce introduced AI Skills for Agentforce Coworker. The pitch is one line: an employee can teach Coworker how to complete a task once, then scale that know-how across the workforce and across the tools they work in. It’s in pilot now, with general availability planned for October 2026.

The judgment to start from: an AI Skill is your fastest path to capturing tribal knowledge, and your fastest path to scaling a bad habit. The capability is useful. The governance around who can teach, and what a taught skill is allowed to touch, is the whole job. Get that backwards and you’ve handed every user a way to encode their personal shortcut into a system other people rely on.

First, untangle the three “skills”

Salesforce has reused the word enough that the first task is disambiguation. Say which one you mean or the meeting goes sideways.

Agent Skills are the developer thing. They’re the open, portable SKILL.md format that teaches a coding agent your Apex, LWC, and Data 360 conventions, the same format Claude Code and Cursor read. They live in a repo, a developer installs them, and they shape how code gets written. Nothing to do with end users.

Topics and actions are the builder thing. They’re how an admin or developer defines what an agent can do, the classification descriptions and scoped actions that decide when the agent calls what. This is governed, tested, and deployed through metadata.

AI Skills are the new thing, and the different thing. They’re taught by an end user inside Agentforce Coworker, in the flow of work, without writing metadata or code. That’s the shift worth paying attention to, because it moves a slice of agent-building out of the admin’s hands.

What an AI Skill is

Coworker itself is the conversational front door Salesforce began auto-enabling in Winter ‘27. It answers a question from your data and routes the next step to whichever agent can act on it. It’s the interpreter and dispatcher; the agents are the hands.

An AI Skill sits on top of that. Rather than an admin defining a new capability in Studio, a person shows Coworker how they do a recurring task, and Coworker can then repeat it and offer it to others.

Salesforce frames it as teaching an agent what your best people know. The way one strong rep handles a renewal check, or one seasoned ops person runs a weekly reconciliation, becomes something the whole team can invoke.

Two properties are worth stating plainly because they’re the ones with consequences. A skill is taught once and then scales, so its reach is many-to-one from the start. And it spans surfaces, following the user into Slack and the other tools Coworker shows up in, rather than living on one page.

One limit of writing this now: the feature is in pilot, and Salesforce hasn’t published the detailed mechanics of the teaching experience, the review flow, or the admin controls. I’m not going to invent screens that may not exist.

What I can do is tell you what’s verifiable, and what to decide before it reaches your org. The decisions are the same whatever the final UI looks like.

The one thing that is not in question: permissions

The most important fact about AI Skills is inherited, not new. Coworker respects the permissions, governance, and sharing rules of the sources it reaches. A user only gets answers built from records and objects they already have access to.

That property carries into a taught skill, and it’s the guardrail that makes the whole idea safe enough to consider. A skill taught by a user runs within that user’s access, and when another user invokes it, it runs within theirs. A skill can’t become a side door to data its caller couldn’t already see.

Lean on this, but don’t over-read it. Sharing controls what a skill can see. It doesn’t control whether the skill’s logic is any good, whether it encodes an out-of-date process, or whether an action it triggers is one you’d want fired at scale.

A skill that only reads permitted data can still confidently teach four hundred people the wrong way to do something. Permissions are necessary. They are not the whole of governance.

Where a taught skill should stop, and a built action should start

Here’s the design line that matters, and it’s the one to settle with your team before GA.

A user-taught AI Skill is the right tool when the task is a convenience: assembling a view, drafting a summary, checking a status, running a sequence of reads and a low-stakes write the user could have done by hand anyway. These are cheap, reversible, and personal. Letting people teach them is how you capture real expertise without a backlog ticket for every one.

An admin-built topic and action is the right tool the moment the task is consequential. Anything that sends an external message, moves money, changes a record the forecast or an SLA depends on, or is hard to reverse belongs in governed actions that were reviewed, tested, and deployed, not in something a user demonstrated on a Tuesday.

The healthy pattern is a promotion path. A skill that starts as one person’s convenience and turns out to be valuable to everyone shouldn’t stay an informal, user-taught artifact forever. That’s the signal to rebuild it as a governed topic and action, with the approval gates its blast radius calls for. Treat popular AI Skills as a discovery mechanism for what to formalize, not as the finished form.

The governance to set up before you turn it on

Because a taught skill scales, the controls belong in place before the teaching starts, not after a skill has spread. Four decisions do most of the work.

Decide who can teach and who can share. Teaching a skill for yourself is low-risk. Publishing one to the workforce is a change to a shared system, and it deserves the same scrutiny you’d give any change that reaches everyone. If the pilot lets you separate those two rights, separate them.

Decide what a skill may trigger. A skill that only reads is a different risk class from one that writes or sends. Keep the consequential actions behind governed, admin-owned actions, so a taught skill can ask to send an email through an approved action but can’t improvise the send itself.

Decide how you review what spreads. Agent sprawl was already the new shadow IT with admin-built agents. AI Skills add a faster, quieter path to the same problem: many small behaviours, taught by many people, few with an owner. You need a way to see which skills exist, which are spreading, and who is accountable for each.

Decide your budget. Every skill invocation is agent work, and agent work consumes credits. A useful skill that spreads to the whole company is a useful skill multiplied by your headcount on your consumption bill. Know how skill usage meters before a popular one surprises finance.

How to pilot it without regret

If you get access to the pilot, treat it like any other agent change, because that’s what it is.

Start with read-mostly skills and a small, willing group. Capture the tasks that are pure time-savers first, the ones where the worst case is a wasted click, and hold the consequential workflows for governed builds. Watch what people teach, because that’s a free requirements document for the topics and actions you should be building anyway.

And test the taught skills the way you’d test any agent: against the messy real cases, not the clean demo. A skill one person taught from their own tidy accounts will meet someone else’s edge cases the moment it scales, and the whole premise of the feature is that it scales.

The feature moves fast at turning expertise into working automation. It also transfers authorship, from the admin who used to own every agent behaviour to the users who now teach some of them.

That transfer is fine, even good, as long as you decide the boundaries first. Teaching should be easy. Scaling should be governed. Keep those two rules and AI Skills earns its place. Blur them and you’ve built an efficient way to make the same mistake in a thousand places at once.

Understanding the basics

What are AI Skills in Agentforce Coworker?

AI Skills let an employee teach Agentforce Coworker how to complete a task once and then reuse and scale that know-how across the workforce and across the tools where Coworker appears. Salesforce introduced them at its September 11, 2026 job-ready agents launch, framed as a way to capture what your best people do and make it repeatable. The feature is in pilot, with general availability planned for October 2026.

How are AI Skills different from Agent Skills and from topics and actions?

Three different things share the word. Agent Skills are the open SKILL.md format that teaches a coding agent your development conventions, aimed at developers. Topics and actions are how an admin or developer defines what an agent can do, governed through metadata. AI Skills are taught by an end user inside Coworker, in the flow of work, without writing code or metadata. The first two are built; AI Skills are taught.

Yes. Coworker respects the permissions, governance, and sharing of the sources it accesses, so a user only receives answers built from records and objects they can already see, and a taught skill runs within the access of whoever invokes it. That prevents a skill from becoming a side door to data. It does not, on its own, guarantee that the skill’s logic is correct or that any action it triggers is safe at scale, which is why review still matters.

When should a user-taught skill become an admin-built action?

Promote it when the task stops being a personal convenience and becomes consequential or widely relied on. Anything that sends external messages, moves money, changes records that forecasts or SLAs depend on, or is hard to reverse belongs in a governed, tested, deployed action with the right approval gates, not in a demonstrated skill. Treat a popular AI Skill as a signal of what to formalize into a topic and action.

Deciding whether to let your team teach Coworker, or where the line sits between a taught skill and a governed action? Talk to us. Setting up the guardrails so agent-building can spread safely instead of turning into sprawl is part of every Agentforce build we do.