Skip to content

forcedotcom/sf-skills / plugins/builder/education-cloud/skills/education-cloud-student-recruitment-agent-configure

education-cloud-student-recruitment-agent-configure

Verified

Use this skill to set up and configure the Education Cloud Student Recruitment Agent (SRA) — the packaged Agentforce agent (namespace sturecruitment) that answers admissions FAQs, captures inquiries, registers campus tours, and files applications for prospective students. TRIGGER when the user wants to: create or configure an admissions, recruitment, or enrollment agent, set up the Student Recruitment Agent, deploy SRA to an Experience Cloud site, clone the SRA flows or permission sets, add the SRA subagents (Admissions and Enrollments FAQ; Admissions Application; Campus Tours, Visits, and Events Registration; Request for Information), wire Learning Program grounding, or build the escalation subagent. Guides platform enablement, permissions, grounding, agent creation, and channel deployment — API-first with UI fallback. DO NOT TRIGGER for the Transfer Credit Agent, generic Agentforce authoring (use agentforce-generate), or base Education Cloud domain enablement (use education-cloud-domain-configure).

references/agent-and-subagents.md

View on GitHub
# Agent creation & the 4 packaged subagents

Read at Workflow steps 9, 9a & 10. **Step 9** is Claude's single headless T1 pass that builds the agent bundle end-to-end and leaves it as an editable draft — template fetch, the ASA running-user creation + sentinel resolution + runtime grants, the ASA default-topic strip, the from-scratch Escalation subagent (handoff-only), and knowledge wiring, all before any `publish`. **Step 9a** is the customer's one Builder session — add the 4 packaged subagents, delete the broken Admissions Application action, add Create Inquiry to the Escalation subagent, then Save + Commit Version once (the one-and-only `validate`+`publish` for this agent). **Step 10** is AEA/Employee-only — the community-user access grants, which genuinely can't happen before the agent exists. Flow cloning (step 11, ASA-only) follows — it has no authoring dependency on the subagents, see `flows.md`.

## Step 9 — Create the agent(s) [T1 — headless, draft only, no publish]

Agent creation does **not** require the Setup UI. The platform's own template catalog is headlessly readable, and a real running user for the ASA path can be minted headlessly too — so the entire agent can be built and left in a committable draft without ever opening Builder. This does **not** mean you can hand-author a bundle with no template backing it (see the packaged-subagent CRITICAL warnings below — those still apply).

**WARNING: Splice the fetched `agentScript` text directly — don't reach for a Python/code-execution tool to do it.** The captured template (point 1 below) is a large (~60KB+) but plain string; stripping the 7 default topic blocks (point 4) and inserting the new Escalation block (point 5) is ordinary text editing against that string, not a task that needs a scripting sandbox. A Python-execution tool may come from a separate, internal-only plugin (e.g. aisuite) that isn't guaranteed to be available in every environment this skill runs in — depending on it breaks the skill wherever it isn't installed.

1. **Fetch the real template.** `GET /services/data/vXX/headless/invoke/platform/agent-authoring/get-agent-templates` → `200 {status_code:200, body:[{devName, namespace, name, agentType, agentScript, templateLabel, templateDescription, iconUrl}, ...]}`. Match by FQN `name` — `SvcCopilotTmpl__AgentforceServiceAgent` (Service) or `EmployeeCopilot__AgentforceEmployeeAgent` (Employee); both are served by this same catalog, not just industry-specific templates. Capture that entry's `agentScript` — the full AFScript body (~60KB+) — as the starting `resourceContent` for the new bundle.
2. **ASA only — resolve the `NEW_AGENT_USER` sentinel with a real user, named so the customer can find it again later.** The fetched Service template's `access.default_agent_user` is the literal string `NEW_AGENT_USER` — Builder's "New User" toggle is what normally resolves this at creation time. Headlessly: create a real user matching Salesforce's own internal Digital Agent User pattern, but with an SRA-identifiable `Name`/`Username` rather than a generic hash — `POST /services/data/vXX/sobjects/User` body `{Name:"SRA Service Agent User", Username:"sra.service.agent.<hash>@salesforce.com", ProfileId:"<Einstein Agent User profile Id>", ...}` (Profile "Einstein Agent User", UserLicense "Einstein Agent", UserType Standard; `<hash>` keeps the username unique, it just no longer carries the whole label). Substitute that user's **Id** (not username) for the `NEW_AGENT_USER` string in `access.default_agent_user`. **CRITICAL: This naming choice matters beyond cosmetics — the customer has to pick this exact user back out of a dropdown at step 9a's Save** (see the CRITICAL warning under step 9a, point 4); a generic `DigitalAgent.<hash>` name is unrecognizable in that list, a named one isn't. The Employee template carries no `access:`/`default_agent_user` block at all — nothing to resolve on the AEA path, and no dedicated running user either (authenticated community users invoke the AEA agent as themselves).
3. **ASA only — grant the running user its full permission-set/license parity, now, using the Id from step 2.** Because Claude minted this user directly, there's no need to wait for a post-commit `BotDefinition.BotUserId` query-back — assign the grants immediately, before the bundle is even created. **Assign the 6 PermissionSetLicenses before the 8 PermissionSetAssignments** — ordering matters here; see `permissions.md`'s three-persona table (Einstein Agent User row) for why and the complete grant list. **CRITICAL:** Without the full set, `publish` (or the customer's Commit Version) fails with a generic, sharing-flavored *"User doesn't have access to agent"* — that's actually a missing-license/permission-set problem, not a visibility one.
4. **ASA only — strip the 7 default generic topics, in the same pass.** The **"Agentforce Service Agent"** template ships pre-populated with 7 generic non-SRA topics — Reservation Management, Service Customer Verification, Account Management, Case Management, Order Inquiries, Delivery Issues, and a pre-built generic Escalation topic — none of which belong on SRA. The **"Agentforce Employee Agent"** template does **not** carry these extras (Employee/AEA gets only the standard scaffolding — Agent Router, Off Topic, Ambiguous Question, General FAQ) — nothing to strip on that path. **Remove all 7 before the bundle is ever created**, then author a new, SRA-specific Escalation subagent from scratch (point 5, below) — the default Escalation topic stripped here is not reused, only its slot in the router. This agent is unauthenticated/guest-facing, and topics like Account Management or Case Management stay wired to real Salesforce actions by default — left in place, an anonymous guest could reach account/case data through them. Treat this as a data-exposure fix, not a scope trim. Delete each default topic's `subagent <Name>:` block and its `go_to_<Name>` entry under the router's `reasoning.actions` — a plain deletion, no new action target, so it doesn't need `validate` on its own.
5. **Both paths — author the custom Escalation subagent, handoff-only, with no Create Inquiry action.** No packaged Escalation subagent exists (don't look for one in the Asset Library), so author the `subagent Escalation:` block by hand: `label`/`description`, `reasoning.instructions` with live-handoff language, and the router wiring (`go_to_Escalation: @utils.transition to @subagent.Escalation` under `start_agent agent_router:` → `reasoning.actions`). Don't add data-retrieval actions to it — that's the FAQ/Application/RFI subagents' job. Content to author:
   - **Classification:** "Handles requests from users who want to escalate."
   - **Scope:** help users who are stuck or want to escalate.
   - **Activation:** trigger on phrases like "Help I'm stuck!", "I want to talk to a live person."
   - **Instructions:** transfer-to-live-agent language, handled by reasoning/runtime with **no explicit transfer action def**.
   - **CRITICAL: Deliberately leave the Create Inquiry action out of this pass** — see step 9a, point 3. Its target (`flow://eduadmissions__CreateInquiry`) is knowable and validate-able without the Asset Library (it's a managed flow that resolves whether or not it's been cloned yet — see step 11), but the action's full input-field mapping (first/last/email, request category, etc.) isn't something Claude can safely infer without discovery, and a wrong mapping produces an action that looks wired but silently mismaps or drops data. The customer adds it via Builder's guided action picker instead.
6. **Both paths — wire knowledge.** Set the top-level `knowledge.rag_feature_config_id = "ARFPC_<libraryId>"` (+ `citations_enabled: true`) — agent-wide, not per-subagent, not a `featureAssignments` write (the library's `featureAssignments` stays `[]`). One field grounds every subagent's existing Answer-Questions-with-Knowledge action; see `grounding.md` (Mechanism 1) for the field shape.
7. **Create the bundle and stop at compile — do not publish.** `POST .../nextgen-authoring/bundles` with the fully-edited `agentScript` inline as `resourceContent` → lands in `DRAFT` state (a brand-new bundle needs no separate draft/PATCH cycle — that's only for editing a bundle that already exists, see step 9a's NGA lifecycle below). `POST .../nextgen-authoring/afscript/compile` (passing the explicit `content` field, not just an Id — `bundleVersionId` alone fails consistently) to catch syntax errors. **Do not call `validate` or `publish` here.** A bundle left in pure DRAFT — never published via the API — is fully visible and editable in Builder (Explorer panel → Subagents → Add from Asset Library works against it), and the customer's own Commit Version in step 9a performs the one-and-only `validate` + `publish` for this agent. Calling `publish` here would mint a throwaway `BotVersion` before the customer's own step-9a edits land in the same version.
   - **Fallback (T3)** if the template fetch or headless bundle-create isn't reachable in a given org: create the agent in Builder from the named template ("Agentforce Service Agent" / "Agentforce Employee Agent"), using the **New User** toggle on the Service agent's creation modal (Employee has no such toggle — authenticated users invoke it as themselves). Everything else in this step (grants, topic-strip, escalation authoring, knowledge wiring) still runs headlessly against that agent's bundle once it exists, via the NGA edit lifecycle below — it just costs an extra GET/draft/PATCH cycle instead of folding into the initial create.

**Metadata keys:**
- Agent template keys: `SvcCopilotTmpl__AgentforceServiceAgent` (Service) / `EmployeeCopilot__AgentforceEmployeeAgent` (Employee) — the stock base-Agentforce templates, served via `get-agent-templates`; **not** `sturecruitment__StudentRecruitment` — the SRA identity comes entirely from the packaged subagents added at step 9a, not from the base template's name.
- Gated by `OrgPermissions.EinsteinForEducationCloud`, `OrgPreferences.RecruitmentAgentEnabled`, `Gater.com.salesforce.StudentRecruitmentAgent256`.
- Topics gated `allowedAgentTypes: [EinsteinServiceAgent, AgentforceEmployeeAgent]` — one subagent set serves **both** agent types.
- Discrete `.genAiPlanner`/`.bot` file names are generated at creation time.
- Service vs Employee is distinguished by `BotDefinition.Type` (`Bot`/`InternalCopilot`/`ExternalCopilot`/`AgentforceOrchestrator`) + `AgentType`.

## Step 9a — The customer's one Builder session: packaged subagents, cleanup & Create Inquiry [T3]

Everything here happens **after** step 9 has left the agent as an editable draft, and is intentionally the *only* point in the whole build where the customer touches Builder. **Open the agent from the Agentforce Studio app** — not Setup → Agents or "Agentforce Agents," a different destination that doesn't launch Builder — then open the draft agent (Agentforce Service Agent / Agentforce Employee Agent) and launch it in Agentforce Builder. It ends in exactly one Commit Version.

1. **Add the 4 packaged subagents from the Asset Library** — Explorer panel → Subagents → the "+" ("Add or create subagent") → Add from Asset Library. This is never a "Topics panel," and there's no "New Topic" control to reach it through — the "+" next to Subagents is the only entry point. Expect a long, unfiltered list here — 20+ subagents from every package/agent installed in the org, not a short SRA-only set — so find each of the 4 real labels by name (see the table below) rather than assuming there's little to sort through. `TransferCreditEquivalency` is worth specifically watching for since it ships in the same `sturecruitment` package and can look like it belongs — but it's one distractor among many, not the only other item in the list; it's the Transfer Credit Agent's, never SRA's. This stays genuinely T3 (see the CRITICAL block below for why). **Use each subagent's real label when talking to the customer** — never shorthand like "FAQ," "Application," "Campus Tours," or "RFI."
2. **Delete the Create Admissions Application action from the Admissions Application subagent.** It's currently non-functional — a platform issue blocks this action everywhere, unrelated to this org's setup. Deleting it doesn't touch the subagent's other actions (timeline/program/term lookups, FAQ answers).
3. **Add Create Inquiry to the Escalation subagent, per the Required Inputs choice.** Claude authored the Escalation subagent handoff-only in step 9, deliberately leaving this action out (see step 9, point 5). In this same session, open the Escalation subagent's action list and add **Create Inquiry** (target `flow://eduadmissions__CreateInquiry`) through Builder's guided action picker, which handles the input-field mapping (first/last/email, request category) correctly — do this if Required Inputs captured a yes; skip this action entirely for handoff-only if it captured a no.
4. **Only then Save, then Commit Version — once.** This is the single `validate` + `publish` for this agent. Nothing before this point is durable/queryable — a build that's only Saved has no `BotVersion`/`BotDefinition` row yet, and any tier-1 verify comes back empty even though the UI looks finished.
   - **CRITICAL: ASA only — Save re-prompts for the running user; tell the customer to pick the existing one, never a new one.** Even though the running-user field already carries the real user's Id from step 9, point 2, clicking Save surfaces Builder's own picker for the agent's running user (worded along the lines of "New User" / "Existing User"). The customer must choose the **existing-user** option — e.g. a **"Select User"** control — and pick the user by its SRA-identifiable name (e.g. "SRA Service Agent User," set in step 9, point 2) from the dropdown. Accepting a "New User" default here mints a second Digital Agent User with none of step 9's permission-set/license grants — the agent then fails to publish, or publishes against the wrong, ungranted user. Skip this on the AEA/Employee path — it has no dedicated running user to reconfirm.

   Confirm all four actions with the customer (subagents added, action deleted, Create Inquiry added or explicitly skipped, save/commit — including selecting the existing running user on the ASA path) before treating this step as done.

### Mechanism — subagents live in the agent's Next-Gen Authoring (NGA) bundle AFScript

A subagent is **not** a standalone `GenAiPlugin` record you create separately — it is a `subagent <Name>:` block inside the agent's **NGA bundle AFScript** (`assets[].resourceContent`). Each block carries `label` / `description` / `reasoning.instructions` / `reasoning.actions` plus an `actions:` section defining every action's `source:` and `target:`. The router (`start_agent agent_router:`) transitions into each subagent via a `reasoning.actions` entry (`go_to_<Name>: @utils.transition to @subagent.<Name>`). This is the same mechanism step 9 uses to author the Escalation subagent and strip default topics — the only difference is step 9 folds its edits into the initial bundle-create body, while any *later* edit (e.g. re-touching an already-created bundle) goes through the GET/draft/PATCH cycle below.

**CRITICAL: The NGA edit lifecycle is tier-1, but the packaged-subagent *injection* is not.** The bundle-version GET/draft/PATCH/validate/publish cycle below runs at tier 1 — but it only *edits* an AFScript you already hold. It cannot supply the packaged targets: those come only from the Asset Library (a T3 builder action — see the CRITICAL block below). So **step 9a's "add the 4 packaged subagents" is T3** (Asset-Library-sourced); the tier-1 NGA lifecycle applies to editing a bundle you already hold (step 9's authoring pass, and any later re-edit). Don't read "NGA is T1" as "you can build the packaged subagents headlessly" — you can't.

**The NGA edit lifecycle — all tier 1 over `dispatch` (Connect API `next-gen-authoring`, v67.0+), for edits to a bundle that already exists:**

**WARNING: This path is keyed by the bundle-version Id (`1bZVW…`), NOT the BotVersion Id (`0X9VW…`).** They are distinct records — passing a BotVersion Id here 404s. Get the bundle-version Id from `GET .../nextgen-authoring/bundles` (list the agent's bundles → its current `bundleVersionId`).

**CRITICAL: Never PATCH a bundle version you haven't confirmed is a draft.** PATCHing an already-`PUBLISHED` bundle version returns `204` but is a **silent no-op** — no error, no write, no state change, no signal anything went wrong. Always create the draft (step 2 below) first and PATCH the resulting `draftBundleVersionId`, never the original.

**CRITICAL: Fully decode `resourceContent` before editing.** HTML-unescape it (repeat passes until no entities remain) before making any change. Resending still-entity-encoded text causes an undocumented, asymmetric double-encoding corruption — some entities double-encode, others don't. Decode once, edit the plain text, re-escape only for JSON-string transport in the PATCH body.

1. `GET .../nextgen-authoring/bundle-versions/{bundleVersionId}` — get the current bundle version (its `assets[].resourceContent` is the AFScript).
2. `POST .../nextgen-authoring/bundle-versions/{bundleVersionId}/draft` — create a draft (**non-destructive**; mints a `draftBundleVersionId`).
3. `PATCH .../nextgen-authoring/bundle-versions/{draftId}` — write the edited `assets`. Compose the edited `resourceContent` directly as part of this request body in one pass — don't write the edit out separately and then re-transcribe it into the PATCH call. Strip read-only sibling fields (e.g. `compileResponse`) from the GET'd asset object before PATCHing it back, or the API 400s with `JSON_PARSER_ERROR`. There is **no partial-update variant** of this endpoint — every PATCH is a full-document replace regardless of edit size, so combine several edits to the same AFScript into **one** draft → one edit → one PATCH → one compile pass rather than a separate cycle per edit.
4. `POST .../nextgen-authoring/afscript/compile` (syntax) **and/or** `POST .../nextgen-authoring/bundle-versions/{draftId}/validate` (existence). **Always pass the explicit `content` field alongside `bundleVersionId` on compile** — calling with `bundleVersionId` alone fails consistently (not transiently) with a generic, unhelpful error.
5. `POST .../nextgen-authoring/bundle-versions/{draftId}/publish` — **DESTRUCTIVE: mints a Bot/BotVersion.** Only call this if you have a specific reason to publish outside the customer's own step-9a Commit Version (the normal path leaves this to them). **CRITICAL: If `validate`/`publish` 500s (`UNKNOWN_EXCEPTION`), don't retry it repeatedly** — try once or twice to rule out a blip, then stop and ask the customer to open the agent in Builder and click **Commit Version**, which re-runs validate/publish server-side and succeeds through outage windows that reject the headless call.

**CRITICAL: compile ≠ validate — never trust compile as proof an action reference is real.** `compile` is **syntactic only** (it also catches internal self-consistency — e.g. a `reasoning.actions` reference with no matching `actions:` definition — but not whether a target actually exists): it accepts any well-formed AFScript and echoes back `source`/`target` even when the target doesn't exist. `validate` is the **authoritative existence check** against the action registry. Always `validate` (or publish) before trusting a reference whenever an edit adds or changes an action target. For a pure-deletion edit that adds/changes no target (e.g. step 9's topic-strip), there's nothing new for validate to check — compile alone is sufficient.

### CRITICAL: Add subagents from the Asset Library — do NOT hand-author the action targets

Adding a packaged subagent from the **Agentforce Asset Library** is **mandatory, not a style preference** — but reach it *from inside the agent*, not a separate Setup destination: open the agent in **Agentforce Builder → Explorer panel → Subagents → the "+" ("Add or create subagent") → Add from Asset Library**. The action `target` is the *underlying invocable resource URI* (a managed flow, prompt template, or standard action) and does **not** derive from the action's `source` name — e.g. source `sturecruitment__CreateCampusTourRegistration` → target `flow://eduadmissions__CreateCampusTourRgstr` (**different namespace AND different API name**). There is **no guessable transform**; only the Asset Library supplies the correct mapping for a first build, and a hand-authored target passes `compile` but fails `validate`.

**CRITICAL: You cannot read the target map to bootstrap a fresh org.** The `GenAiPluginDefinition` (subagent) and `GenAiFunctionDefinition` (action `source`/`InvocationTarget`/`InvocationTargetType`) records are **per-agent-version copies minted when a subagent is added to an agent** — their `DeveloperName`s are suffixed with the parent `GenAiPlannerDefinition` Id (e.g. `AdmissionsApplication_16jVW000000QkNN`). On a fresh org that has not yet added the SRA subagents, these queries return **0 rows** — there is nothing to read, because the mapping doesn't exist until the Asset Library puts it there. The read surface is therefore a **verify-/read-back capability** for an org that already has the subagents (see Verify below), **not** a way to discover targets before the first add. The initial injection must come from the Asset Library.

Adding from the library edits the AFScript in exactly **two** places, and the router auto-wires — no separate wiring step: (a) inserts the `subagent <Name>:` block (with its `reasoning.actions` + `actions:` `source`/`target`/`inputs`/`outputs`), and (b) adds `go_to_<Name>: @utils.transition to @subagent.<Name>` under `start_agent agent_router:` → `reasoning.actions`.

### The complete action→target map (4 packaged subagents + custom escalation)

Four target **schemes** are in play — this is the taxonomy to expect when reading back the AFScript:

| Subagent | Action (`source`) | `target` | Scheme |
|---|---|---|---|
| CampusTourVstAndEvntRgstr | `sturecruitment__CreateCampusTourRegistration` | `flow://eduadmissions__CreateCampusTourRgstr` | flow |
| CampusTourVstAndEvntRgstr | `sturecruitment__GetCampusTourCampaigns` | `flow://eduadmissions__GetPlnCampaigns` | flow |
| AdmissionsAndEnrollmentsFaq | `sturecruitment__GetLearningProgramData` | `generatePromptResponse://sturecruitment__getLearningPrograms` | prompt-template |
| AdmissionsAndEnrollmentsFaq | `sturecruitment__GetAcademicTermData` | `generatePromptResponse://sturecruitment__getAcademicTerms` | prompt-template |
| AdmissionsAndEnrollmentsFaq | `sturecruitment__GetApplicationTimelineData` | `generatePromptResponse://sturecruitment__getApplicationTimelines` | prompt-template |
| AdmissionsAndEnrollmentsFaq | `EmployeeCopilot__AnswerQuestionsWithKnowledge` | `standardInvocableAction://streamKnowledgeSearch` | standard |
| AdmissionsApplication | `sturecruitment__CreateAdmissionsApplication` | `api://Industries-Education.postPreliminaryApplicationReferences` | **api (Connect REST) — currently non-functional; delete right after adding this subagent (step 9a), see below** |
| AdmissionsApplication | `sturecruitment__GetProgramTermApplicationTimelineData` | `standardInvocableAction://getProgramTermApplTimelineData` | standard |
| AdmissionsApplication | `sturecruitment__GetAcademicTermData` | `generatePromptResponse://sturecruitment__getAcademicTerms` | prompt-template |
| AdmissionsApplication | `sturecruitment__GetLearningProgramData` | `generatePromptResponse://sturecruitment__getLearningPrograms` | prompt-template |
| AdmissionsApplication | `EmployeeCopilot__AnswerQuestionsWithKnowledge` | `standardInvocableAction://streamKnowledgeSearch` | standard |
| RequestForInformation | `sturecruitment__CreateAcademicInterest` | `flow://eduadmissions__ProcessAcademicInterest` | flow |
| RequestForInformation | `sturecruitment__GetAcademicTermData` | `generatePromptResponse://sturecruitment__getAcademicTerms` | prompt-template |
| RequestForInformation | `sturecruitment__GetLearningProgramData` | `generatePromptResponse://sturecruitment__getLearningPrograms` | prompt-template |
| Escalation (custom, authored step 9, action added by customer step 9a) | `sturecruitment__CreateInquiry` | `flow://eduadmissions__CreateInquiry` | flow — target is validate-able without the Asset Library (see step 9, point 5), but the customer adds the action itself via Builder's action picker |

Note two subtleties in the table: (1) the FAQ `Get…Data` actions are `generatePromptResponse://` **prompt-template** invocations — the concrete Step 8 grounding tie-in; (2) `AnswerQuestionsWithKnowledge` is `EmployeeCopilot__`-namespaced (the base-template knowledge action), not `sturecruitment__` — a subagent mixes base-template and packaged actions. The FAQ subagent's `GetApplicationTimelineData` (prompt-template) is a **different action** from the Application subagent's `GetProgramTermApplicationTimelineData` (`standardInvocableAction://getProgramTermApplTimelineData`) — keep them distinct despite the similar names.

### The Admissions Application `api://` action — currently broken; delete it at step 9a

`CreateAdmissionsApplication` is the **only `api://`-scheme action** across all four subagents (it posts to the Admissions "Preliminary Application References" Connect endpoint, not a flow). Its target `api://Industries-Education.postPreliminaryApplicationReferences` is currently blocked by a platform-level issue affecting this action everywhere — not a license, user-permission, or recruitment-toggle problem, and not specific to this org. If `validate`/`publish` rejects only this one action with *"Invocable action 'Industries-Education.postPreliminaryApplicationReferences' does not exist"* while every other action still validates, that's this issue, not a misconfiguration on your side.

**The fix at this stage is to delete the action, not to chase the registration or build a workaround** — see the deletion step under step 9a above. Don't spend time re-registering it, re-adding it a different way, or wrapping it in Apex. Delete it and move on — the rest of the AdmissionsApplication subagent (timeline/program/term lookups, FAQ answers) is unaffected.

**Three failure modes for a subagent action target — diagnose in this order:**
1. **Wrong string** (compile passes, validate fails) → you hand-authored it; re-add the subagent from the Asset Library.
2. **Correct string, unregistered agent action** (validate fails "does not exist" though the underlying resource is live) → for `Industries-Education.postPreliminaryApplicationReferences` specifically, this is the known issue above — delete it (step 9a). For any other `api://` action showing this pattern, treat it as a genuine provisioning gap and escalate to the feature owner.
3. **Correct string, registered** → validates and publishes.

### The 4 packaged subagents

Add these from the **asset library**:

| Subagent (label) | `GenAiPluginDefinition` dev name | Key actions |
|---|---|---|
| Admissions and Enrollments FAQ | `sturecruitment__AdmissionsAndEnrollmentsFaq` | AnswerQuestionsWithKnowledge, GetLearningProgramData, GetAcademicTermData, GetApplicationTimelineData |
| Admissions Application | `sturecruitment__AdmissionsApplication` | CreateAdmissionsApplication, GetAcademicTermData, GetLearningProgramData, GetProgramTermApplicationTimelineData, AnswerQuestionsWithKnowledge |
| Campus Tours, Visits, and Events Registration | `sturecruitment__CampusTourVstAndEvntRgstr` | CreateCampusTourRegistration, GetCampusTourCampaigns |
| Request for Information | `sturecruitment__RequestForInformation` | CreateAcademicInterest, GetAcademicTermData, GetLearningProgramData |

> **Do NOT include `TransferCreditEquivalency`.** That YAML in the `sturecruitment` package belongs to the separate Transfer Credit Agent (own `TransferCreditEquivalencyAccess` perm, own help) — it is not part of SRA. It's easy to miss among the Asset Library's other entries (see step 9a, point 1, on why that list is long) since it ships in the very same package as the real 4.

### Retrieval-action grounding note (ties step 9a to step 8)

- The FAQ, Application, and RFI subagents' **`Get … Data` retrieval actions are backed by prompt templates + retrievers** wired in step 8 (`grounding.md`). Only **3 base-SRA prompt templates** exist: `getLearningPrograms`, `getAcademicTerms`, and `getApplicationTimelines`. **WARNING: `getApplicationTimelines` grounds the PTAT entity** (DMO `ssot__ProgramTermApplicationTimeline__dlm`), NOT `ApplicationTimeline` — the "Application Timeline" display name is misleading; `grounding.md`'s Mechanism 2 table (row 3) owns this. So the FAQ subagent's retriever-backed `GetApplicationTimelineData` (this template) is PTAT-grounded, and is a **different action** from the Application subagent's deterministic `GetProgramTermApplicationTimelineData` invocable (next bullet) — both touch PTAT but via different mechanisms. Do NOT expect (or wire) the 2 Transfer-Credit-Agent templates — they belong to a separate agent (see the TransferCreditEquivalency exclusion above).
- **CRITICAL: `GetProgramTermApplicationTimelineData` stays a STANDARD_INVOCABLE action** (deterministic — it invokes the packaged flow/apex, not a free-form retriever). Do not convert it to a generated retriever action; its grounding (PTAT DMO) is set up in step 8 but the *action* type is fixed.

## Step 10 — AEA/Employee-only: enable community access [T1 write]

Step 10 covers only the AEA/Employee path's community-user access. The ASA/Service path has nothing left here — topic cleanup, escalation authoring, knowledge wiring, and running-user grants all happen in **step 9**. Skip this step entirely on an ASA-only build.

- The `SRA_Exprc_Cloud_Access` clone (built + configured at Step 4 — Run Flows + object settings, no agent required — see `permissions.md`) needs **Enable Agent Access → the AEA agent** set on it. By step 10 the AEA agent is already committed — step 9a's Commit Version precedes this step — so it's selectable against a real `BotDefinition`, not a draft.
- **Then query community users and ask before assigning** — community users are independent of the Experience Cloud site, so don't defer to Step 12. Read existing community users (profiles `Customer Community Plus User` / `Customer Community User`) at tier 1, then ask, e.g. *"I see you have N community users — want me to turn on agent access for them now? If not, you'll need to grant them access later so they can reach the agent."* Per the customer's answer, assign the clone + the sibling PSs (Prompt Template User, Knowledge, Data Cloud starter) to those users (`DUPLICATE_VALUE` on an existing assignment is benign).

## Verify (attempt T1 `/query`/`/tooling/query` → `sf` fallback)

Agent/subagent creation is provisioning-gated (the org must be Agentforce-provisioned — a step-1 verify, not this step's concern), but the result is verifiable at **tier 1**. Run the three SOQL projections below at tier 1 — the agent read over `/services/data/vXX/query` and the subagent + action-target reads over `/services/data/vXX/tooling/query/`, all `dispatch_readonly` — and fall back to the identical `sf` forms only if tier 1 is unavailable.

1. **Agent exists, is active, and has a running user** — `SELECT Id, DeveloperName, MasterLabel, Type, BotUserId FROM BotDefinition WHERE DeveloperName LIKE '%Recruit%' OR DeveloperName LIKE '%StudentRecruitment%'`. For the **ASA/Service agent**, `BotUserId` should be the exact user created and granted in step 9 — a **null** `BotUserId` means the sentinel substitution was skipped — treat it as a build error to fix, not an expected state.
2. **Subagents present** (packaged + custom escalation) — `SELECT DeveloperName, MasterLabel FROM GenAiPluginDefinition` on the **tooling** query surface. **WARNING: Query `GenAiPluginDefinition`, not `GenAiPlugin`** — see `execution-model.md`'s query-routing nuance (a) for why. `GenAiPluginDefinition` is the child of `GenAiPlannerDefinition` via `ParentId`; `GenAiPlannerDefinition` is also tooling-queryable for the planner read-back. Each subagent's `DeveloperName` is **suffixed with its parent planner Id** (e.g. `AdmissionsApplication_16jVW000000QkNN`), because these rows are per-agent-version copies minted at add-time — so match the suffix to the target agent's `GenAiPlannerDefinition` Id to confirm the subagents landed on the *right* agent.
3. **Action targets landed correctly** (strong verify — asserts the full source→target map, not just presence) — `SELECT DeveloperName, PluginId, InvocationTarget, InvocationTargetType FROM GenAiFunctionDefinition` on the **tooling** surface. `PluginId` FKs back to the `GenAiPluginDefinition` subagent; `InvocationTarget` + `InvocationTargetType` give each action's resolved target (e.g. `CreateCampusTourRegistration` → `eduadmissions__CreateCampusTourRgstr`, type `flow`). Join to step 9a's action→target table to confirm every action resolved to the expected target. This is the authoritative post-add read; it returns **0 rows on an org that hasn't added the subagents yet** (nothing to read — not an error).

```bash
# Tier-2 fallback (same SOQL as the three tier-1 reads above):
sf data query -q "SELECT Id, DeveloperName, MasterLabel, Type, BotUserId FROM BotDefinition WHERE DeveloperName LIKE '%Recruit%' OR DeveloperName LIKE '%StudentRecruitment%'" --target-org <alias>
sf data query --use-tooling-api -q "SELECT DeveloperName, MasterLabel FROM GenAiPluginDefinition" --target-org <alias>
sf data query --use-tooling-api -q "SELECT DeveloperName, PluginId, InvocationTarget, InvocationTargetType FROM GenAiFunctionDefinition" --target-org <alias>
```

Confirm the 4 packaged subagents are present, plus the custom escalation subagent (step 9). Confirm `CreateAdmissionsApplication` is **absent** from the AdmissionsApplication subagent's rows in call 3 — it should have been deleted at step 9a. If it's still there, the deletion didn't take (or was skipped) — delete it in Builder and re-commit before treating step 9a as done.

Conversational smoke test (step 13, user-run in the deployed channel — not headless): send an escalation phrase ("I want to talk to a live person") and confirm the Escalation subagent triggers handoff and, if Create Inquiry was added, produces the inquiry records (Case + Educational Info Request + Academic Interest).
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall