Agentforce Persona Generate

Designing Agent Persona

How to Use

This skill designs an AI agent persona for Salesforce Agentforce. It walks through four sequenced phases (DRAFT → REFINE → SCORE → ENCODE) and offers five spokes (NAME, FILL OUT, ADJUST, CHECKLIST, WORKSHOP) you can run any time after DRAFT.

What it produces:

• A persona document (persona/[agent-name]/persona.md) — who the agent is, how it sounds, what it never does
• A sample dialog (persona/[agent-name]/sample-dialog.md) — the persona in action
• An evaluation report on request (persona/[agent-name]/evaluation.md) — 100-point rubric, gap analysis, recommendations
• A completeness checklist on request (persona/[agent-name]/checklist.md) — what's filled in, what's missing
• A workshop outline on request (persona/[agent-name]/workshop-outline.md) — stakeholder questions, dimension cards
• An encoding artifact on request — valid Agent Script .agent file, OR Agentforce Builder field values

Session resumption: If you stop mid-phase, your progress is preserved in the conversation and can be resumed.

When to Use This Skill

• Designing a new Agentforce agent and need to define its personality before building (greenfield)
• Auditing an existing .agent file's persona consistency (brownfield)
• Translating brand guidelines into a structured persona
• Producing a stakeholder workshop outline to gather design input
• Aligning teams on what an agent should sound like before development

Scope boundary: This skill defines WHO the agent is. It does not define dialog flows, subagents, actions, routing, or variables — those are agent design (use agentforce-generate). The encoding output for Use Case A produces an .agent skeleton with placeholders for those structures; the user fills them in.

Framework Reference

Read references/persona-framework.md for the full framework. It defines:

• Identity — 3-5 anchoring adjectives + Negative Identity (≥2 character-level anti-patterns)
• 14 dimensions (Personification + the 13 expression dimensions):
  • Personification — Talking System / Familiar Thing / Personal Assistant
  • Register — Subordinate / Peer / Advisor / Coach
  • Voice — Formality, Warmth, Personality Intensity, Reading Level
  • Tone — Emotional Coloring, Empathy Level (+ Tone Boundaries, Tone Flex)
  • Delivery — Brevity, Humor
  • Chatting Style — Emoji, Formatting, Punctuation, Capitalization
• Persona Artifacts — Identity (traits + negative identity), Expression (tone boundaries + never-say + guardrails), Phrasing (phrase book + discourse markers + lexicon)
• Tone Flex — how tone shifts by context (including per-subagent calibration)
• Lexicon — global and per-subagent vocabulary, including immutable terms
• Guardrails — content-level boundaries (e.g., "Don't offer medical advice"), distinct from Never-Say

Attributes are ordered by dependency. Identity → Personification → Register → Voice → Tone → Delivery → Chatting Style. Constraint notes recommend natural pairings; any combination is valid.

Attribution for the external sources this skill draws on is in references/attributions.md.

Pre-DRAFT Triage — Greenfield or Brownfield?

Before anything else, ask the user which lane they're on. The two lanes diverge significantly downstream.

Welcome. Two ways to use this skill:

1. Starting fresh — design a persona from scratch using brand input, audience details, and channel. Greenfield.
2. Auditing an existing agent — review and improve a .agent file you already have. Brownfield.

Which one?

Set a mode flag in state: greenfield or brownfield.

Brownfield triggers:

• User uploads a .agent file → load via scripts/parse_agent_yaml.py (read-only)
• ADJUST spoke is immediately available (subagents and actions exist)
• SCORE includes per-subagent and per-action sub-scoring
• ENCODE produces annotated proposed-new-file + diff summary, never inventing structure

Greenfield triggers:

• ENCODE produces a starter .agent skeleton with placeholders for subagents/actions/routing
• ADJUST spoke is initially gated (offered only if user later declares subagents)

Architecture: Phases and Spokes

Phases are sequenced — order matters. Spokes orbit the hub, available any time after DRAFT, in any order. The hub is presented after every phase or spoke exit.

SEQUENCED PHASES (linear pipeline):
  DRAFT → REFINE → SCORE → ENCODE
                          ↑
              (loop back via phases or spokes if SCORE finds gaps)

SPOKES (radiate from the HUB; any time after DRAFT):
  ⊙ NAME              — pick or confirm the agent's name
  ⊙ FILL OUT          — phrase book, never-say, lexicon, immutable content
  ⊙ ADJUST            — subagent + action persona calibrations (gated)
  ⊙ CHECKLIST         — "What's filled in?" — completeness gap analysis
  ⊙ WORKSHOP          — stakeholder workshop outline

The HUB suggests the next default but lets the user pick anything, including re-running the phase or spoke they just exited.

PHASE 1 — DRAFT

DRAFT applies "start small": Identity Traits before dimensions. The user can exit DRAFT after the start-small checkpoint and return later via spokes or re-enter DRAFT.

Step 1: Input

Accept any starting input. No detection question — accept whatever the user provides.

Accepted inputs:

• Brand guide or tone-of-voice document (PDF, text)
• Organization URL
• Prior persona document (persona.md from a previous session)
• Free-text description (e.g., "a sales coach who talks like Crocodile Dundee")
• Existing agent system prompt or .agent file (brownfield mode)
• Any combination

If the user provides nothing:

"Share something to get started — a brand guide, a URL, or just describe the agent in your own words."

Step 2: Context (Essentials)

These four are required:

1. Channel — pick exactly one:

   • Web chat (text)
   • Mobile chat (text)
   • SMS (text — short-form, char-budgeted, no rich text)
   • Email
   • Telephony (voice over phone — voice selection, AI disclosure, formatting suppression)
   • Multimodal-with-audio (chat UI plus agent speaks)
   • Embedded / in-app
   • Other (free-text)

   Channel constrains Brevity defaults (SMS → Terse, Telephony → Concise, web/mobile chat → Moderate, email → Expansive) and rich-text features. Multi-channel + dynamic personas is a roadmap item — for this version, one channel.

2. Company / Brand — extract from input or ask. Who they are, what they do.

3. Audience — who the agent serves: employees, customers, partners, mixed.

4. ≥1 Use case — drives REFINE's sample dialog. If the user can only name one, that's enough.

Conditional context — apply each rule; ask only when its condition fires:

• Primary language — if input does not state or imply the working language, ask (it affects formality norms).
• Business goals + success metrics — if input names no goal or metric, ask for one (it informs proactivity, register, empathy).
• Legal/compliance — if input mentions healthcare, finance, insurance, legal, or other regulated domains, OR contains language that reads like it was written by a legal team: set regulated_industry = true and ask about legal/compliance constraints.

Do NOT collect: subagents, actions, routing structure, or agent name (NAME is its own spoke).

Working title detection: If the user refers to the agent by a working title in input ("the quoting agent," "Flex 2.0"), capture it as display_name_placeholder in state. NAME spoke uses this as a default.

Extraction before asking: Parse input for context signals before asking. "Design an internal sales coach for Buc-ee's" already answers audience (internal), role (sales coach), and brand. Don't re-ask.

Step 3: Identity Traits + Negative Identity

This step is the start-small anchor. Generate:

• Identity Traits — 3-5 adjectives with behavioral definitions (e.g., "Composed: doesn't escalate emotionally even when the user does")
• Negative Identity — 2-4 character-level anti-patterns ("Not a salesperson: doesn't push, recommends what fits")

Identity Traits anchor everything that follows.

START-SMALL CHECKPOINT (explicit, spoken aloud)

After Identity Traits + Negative Identity are locked, write the persona document to disk as it stands and announce the off-ramp:

"We have enough to ship a minimal persona. Here's what it has so far:

• Identity: [traits]
• Negative Identity: [anti-patterns]
• Channel: [channel]
• Company / Audience: [values]
• Use case: [first use case]

Want to keep going through Personification and the rest of the dimensions, or stop here and pick from the hub?"

If the user stops here, dimensions get framework defaults derived from Identity + Channel. The persona document is on disk; the user can see exactly what they've got.

Step 4: Personification (the 14th dimension)

Personification slots in right after Identity. It determines whether the rest of the dimensions are doing character work or transactional work.

Auto-suggest from Identity Traits; the user confirms or overrides.

Step 5: Remaining Dimensions

Walk the dependency chain: Register → Voice (Formality, Warmth, Personality Intensity, Reading Level) → Tone (Emotional Coloring, Empathy Level + Tone Boundaries, Tone Flex) → Delivery (Brevity, Humor) → Chatting Style (Emoji, Formatting, Punctuation, Capitalization).

Brevity defaults are bound to channel — SMS → Terse, Telephony → Concise, web/mobile chat → Moderate, email → Expansive. Override only when a strong signal warrants.

For each dimension:

1. Pre-populate from input signals
2. Mark confidence (strong = strong signal from input; no marker = default)
3. Show the full spectrum and the recommended position

Generate at the end of Step 5:

• Phrase Book — 2-4 phrases per applicable category (Acknowledgement, Affirmation, Apologies-for-mistakes, Off-Topic Redirect, Welcome, Discourse Markers; conditional: Escalation/Handoff for external, Celebrating Progress for Encouraging coloring, Teaching Moments for Coach register, Humor Examples for Humor ≠ None)
• Never-Say List — ≥5 entries (chatbot filler + register violations + cognitive-processing markers + persona-specific)
• Tone Boundaries — what the agent must never sound like
• Tone Flex — baseline + triggers + shift rules
• Global Lexicon — brand name, product names, industry terms used everywhere. Distinguish editable from immutable.
• Guardrails — content-level boundaries; include when the domain warrants ("Don't offer medical advice"). Distinct from Never-Say.
• Values — include only when the user states them explicitly; never inferred.

Cross-cutting verbatim guardrail: Never alter content the designer marks as immutable (legal disclaimers, brand-defined terminology). If a phrase book entry or lexicon term conflicts with immutable content, the immutable content wins.

DRAFT Exit

Persona document is on disk. State carries:

• Mode (greenfield/brownfield)
• Channel
• Company, Audience, Use cases
• Identity Traits, Negative Identity
• Personification + 13 dimensions (filled or defaulted)
• Confidence annotations
• Phrase Book, Never-Say, Tone Boundaries, Tone Flex, Lexicon
• Guardrails (if any), Values (if explicit), Immutable content blocks
• display_name_placeholder (working title from input, if detected)
• name_decision: pending

Present the HUB.

PHASE 2 — REFINE

Generate sample dialog and let the user iterate.

Sample Dialog Generation

Use the Use cases captured in DRAFT step 2 as scenario seeds. Generate 3-5 exchanges that:

• Demonstrate the persona in action (word choice, tone, brevity, humor, formatting)
• Include at least one "interesting" turn — error, clarification, emotional moment — not just happy path
• Make the persona's impact obvious — none of these agents say "Hello! How can I help you today?"

For voice/telephony channels, start with the welcome message including AI disclosure so the user sees it in context.

Refinement Loop

After presenting the sample dialog:

"Tell me what to change — 'make it warmer,' 'drop the humor,' 'don't say that' — or pick:

• Looks good — back to the hub
• Try a different scenario
• (free-text always available)"

When the user types a natural-language adjustment, apply it via the mapping table in references/refinement-mappings.md (e.g., "warmer" → Warmth +1, also consider Empathy +1), regenerate the sample with the change held single-axis, and re-present. When ambiguous, apply the primary mapping and narrate the change so the user can correct.

Diff-Based Regeneration — After a single-dimension change:

1. Show the change explicitly: "Warmth: Warm → Cool"
2. Hold ALL unchanged dimensions constant
3. Regenerate sample dialog varying only the changed dimension
4. Narrate what shifted

Contrasting Response Comparison — If the user asks ("show me two ways this agent could respond"), generate one user utterance from a captured use case + two contrasting agent responses varying along one dimension or trait (not multiple axes). Update state from the user's choice.

REFINE Exit

Sample dialog written to persona/[agent-name]/sample-dialog.md. Persona document updated if dimensions shifted. Present the HUB.

PHASE 3 — SCORE — "How good is it?"

Apply the 100-point rubric. Two entry points:

1. Designed persona (state from DRAFT/REFINE)
2. Existing agent instructions (brownfield mode — .agent file, system prompt, topic instructions, or combination)

Key principle: Score the substance, not whether they used the framework's vocabulary. "Personality guidelines" = Identity. "Communication rules" = dimensions. "Banned phrases" = Never-Say. Map first, then score.