Back to Insights
    AI & Innovation · Agentforce · Platform

    Custom Lightning Types (CLT): Rendering Rich UI Inside the Agentforce Conversational Panel

    Salesforce's newest Agentforce release lets agents return Lightning Web Components — not just text — inside the conversational panel. Branded cards, pickers, signature pads and KPI widgets, all natively rendered, all typed, all reusable.

    Thought Leadership11 min readJune 2026
    Quick Answer

    What are Custom Lightning Types in Agentforce and why do they matter?

    Until now, Agentforce replies were limited to plain text and markdown. Anything richer — booking a slot, signing a quote, picking an asset — meant pushing the user out of the panel into a record page or modal.

    Custom Lightning Types (CLT) let an Agentforce Action return a typed payload that is rendered by a Lightning Web Component inside the conversational panel itself. The agent stays in conversation, the user stays in flow, and the team reuses the same component across Service, Sales, Mobile and Embedded channels — with the Trust Layer, permissions and masking automatically applied.

    What CLT actually is

    Six things every Agentforce team should know

    Typed payloads
    Every CLT defines a strongly-typed schema for what the agent returns — fields, required, lists, references.
    LWC rendering
    The renderer is just a Lightning Web Component. Reuse your existing component library and design tokens.
    Agent-aware
    Component events become new conversational turns, so the agent can continue reasoning on user input.
    Native panel
    Renders inline in the Agentforce panel across Service, Sales Console, Mobile and Embedded Service.
    Trust Layer
    Inherits permissions, field-level security, masking and audit — same governance as the rest of the agent.
    Reusable
    One typed component works across Topics, Actions and channels — no per-assistant rebuild.
    Inside the panel

    What CLT looks like in the Agentforce panel

    Two illustrative views — a typed BookingPicker rendered inside the conversational panel, and the underlying CLT definition + LWC renderer.

    Agentforce Panel — CLT rendering
    Illustrative UI
    Record context · Case 00012345
    AccountNorth Star Logistics
    AssetConveyor unit CL-7
    PriorityHigh

    Figure 1 — A typed CLT (BookingPicker) rendered inside the Agentforce panel. Selecting a slot is a new conversational turn (illustrative).

    Custom Lightning Type — definition
    Illustrative
    // 1. Define the typed payload (CLT metadata)
    @CustomLightningType('BookingPicker')
    export class BookingPickerType {
      @field({ required: true })  caseId: string;
      @field({ type: 'list' })    slots: Array<{ start: string; engineerId: string }>;
    }
    
    // 2. Build the LWC renderer
    import { LightningElement, api } from 'lwc';
    export default class BookingPicker extends LightningElement {
      @api payload;   // typed as BookingPickerType
      @api respond;   // sends a new turn back to the agent
    
      pick(e) {
        this.respond({ chosenSlot: e.target.dataset.start });
      }
    }
    
    // 3. Bind it to your Agentforce Action's response type
    //    → Agent renders it natively in the conversational panel.

    Figure 2 — Defining the CLT schema and binding the LWC renderer (illustrative).

    Why customers care

    From chat replies to one-tap actions

    CLT closes the last-mile UX gap between "the agent told me what to do" and "the agent did it with me, right here in the panel."

    Higher containment
    Users complete tasks inside the panel — booking, signing, picking, confirming — without tab-switching to a record page. Fewer abandons, more first-contact resolution.
    Faster handle time
    Replace long paragraphs of agent text with branded cards, pickers and forms. Service reps and end-customers both move quicker.
    Consistent brand
    Your existing LWCs, design tokens and component library — not generic chat bubbles. The agent looks like part of your product.
    Better data quality
    Structured inputs flow back to the agent as typed objects, not free-text the LLM has to parse and validate. Downstream automation gets cleaner.
    Safer interactions
    PII masking, FLS and Trust Layer policies are applied at the panel, the same way they would be on a record page. Compliance teams stay happy.
    Channel reach
    Same CLT renders inside Service Console, Sales Console, Mobile Agentforce and Embedded Service — write once, render everywhere.
    Developer guide

    Building a Custom Lightning Type, step by step

    The shortest path from a use case to a typed component rendered inside the Agentforce panel.

    1
    Define the typed payload
    Declare a Custom Lightning Type with its schema — fields, required flags, lists, references. This is what the agent will return; it is also the contract your LWC renderer can rely on.
    2
    Build the LWC renderer
    Write a normal Lightning Web Component that exposes @api payload (typed) and @api respond. Render whatever UI you want — cards, pickers, signature pads, KPI widgets — using your existing design system.
    3
    Bind it to an Agentforce Action
    In Agentforce Builder, set the Action's response type to your new CLT. The Builder validates the schema and the panel will render the LWC automatically when the agent invokes the Action.
    4
    Round-trip user events
    Calling this.respond({ … }) inside the LWC submits a new conversational turn with a typed object. The agent reasons over it like any other tool result.
    5
    Wire up Data Cloud + Apex
    Inside the Action, pull live data from Data Cloud, Apex or MCP tools, shape it to the CLT schema, return it. The Trust Layer enforces permissions, masking and audit — same as any other Action.
    6
    Test, version, deploy
    Use the Builder test panel to invoke the Action and inspect the rendered CLT. Version the CLT, the LWC and the Action together; promote through environments with normal Salesforce DX.
    Custom Lightning Type — definition
    Illustrative
    // 1. Define the typed payload (CLT metadata)
    @CustomLightningType('BookingPicker')
    export class BookingPickerType {
      @field({ required: true })  caseId: string;
      @field({ type: 'list' })    slots: Array<{ start: string; engineerId: string }>;
    }
    
    // 2. Build the LWC renderer
    import { LightningElement, api } from 'lwc';
    export default class BookingPicker extends LightningElement {
      @api payload;   // typed as BookingPickerType
      @api respond;   // sends a new turn back to the agent
    
      pick(e) {
        this.respond({ chosenSlot: e.target.dataset.start });
      }
    }
    
    // 3. Bind it to your Agentforce Action's response type
    //    → Agent renders it natively in the conversational panel.
    Developer pro-tips from KVP's Agentforce pod
    • • Keep CLT schemas small and composable — three small types beat one mega-type.
    • • Treat the LWC renderer as presentation-only; never put business logic in it.
    • • Always pass an idempotency key in respond() so re-renders don't double-submit.
    • • Build an internal CLT pattern library: BookingPicker, QuoteCard, SignaturePad, KPIBlock. Reuse across topics.
    • • Cover every CLT with an Agent eval — assert that the right type was returned with valid payload.
    Salesforce strategy

    CLT is the UI layer of Salesforce's Agentforce platform play

    Every Agentforce release this year has strengthened a different layer of the same stack. CLT closes the loop on the user-facing surface.

    Builder
    Visual canvas for Topics, Actions and MCP tools — admin-led agent assembly.
    Atlas reasoning
    Plan-and-execute reasoning across enterprise data and tools.
    Data Cloud
    Grounding with field-level retrieval and unified profiles.
    CLT (new)
    Rich, interactive UI rendered natively in the conversational panel.

    Why this is strategic, not cosmetic

    Salesforce is positioning Agentforce as the default agentic surface on top of the Customer 360. Builder made agent assembly low-code; MCP made tool-use open; Data Cloud made grounding native; CLT now makes the user experience as rich and reusable as a Lightning record page. Together they push every layer of the stack — orchestration, reasoning, grounding, and now UI — into the same governed platform, so customers can scale from one agent to many without building a parallel UX stack on the side. For CIOs evaluating "build vs. buy" agent platforms, CLT removes one of the last reasons to wrap Agentforce inside a custom front-end.

    Slide deck

    The CLT for Agentforce slide deck

    A 6-slide, social-ready summary. Download as PDF for LinkedIn, or share a single slide.

    KVP Carousel · 6 slides · Save & share
    KVP Business Solutions
    Agentforce · CLT · 2026
    New Salesforce Release

    Custom Lightning Types in the Agentforce Panel

    Rich, interactive UI — right inside the conversation.

    Custom Lightning Types (CLT) let agents return Lightning Web Components instead of plain text — quote cards, signature pads, asset finders, KPI widgets — rendered natively in the Agentforce conversational panel.

    CLTLWCAgentforceUX
    A KVP POV
    Swipe →
    kvpcorp.com1 / 6© KVP Business Solutions
    KVP Business Solutions
    Agentforce · CLT · 2026
    What CLT actually is

    Six things every team should know

    Typed payloads
    Strongly-typed schema for what the agent returns.
    LWC rendering
    Any Lightning Web Component can be the renderer.
    Agent-aware
    Components can call back actions & continue the dialog.
    Native panel
    Renders inline in Service, Sales, Mobile & Embedded panels.
    Trust Layer
    Inherits permissions, masking & guardrails.
    Reusable
    Same type works across topics, actions, channels.
    kvpcorp.com2 / 6© KVP Business Solutions
    KVP Business Solutions
    Agentforce · CLT · 2026
    Why customers care

    From chat replies to one-tap actions

    Higher containment
    Users complete tasks inside the panel — no tab-switching to a record page.
    Faster handle time
    Branded cards, pickers and forms instead of long paragraphs of text.
    Consistent brand
    Your existing LWCs and design tokens — not generic chat bubbles.
    Better data quality
    Structured inputs flow back as typed objects, not free-text the agent must parse.
    kvpcorp.com3 / 6© KVP Business Solutions
    KVP Business Solutions
    Agentforce · CLT · 2026
    Developer flow

    Define · Render · Wire — three steps

    1 · Define the type
    Declare the CLT metadata + schema (fields, validations) the agent will return.
    2 · Build the LWC renderer
    Write a normal LWC that takes that typed payload as @api and renders the UI.
    3 · Bind to an Action
    Set the Agentforce Action's response type to your CLT — Agent renders it automatically.
    4 · Round-trip events
    Component @api events become new turns, so the agent continues the conversation.
    kvpcorp.com4 / 6© KVP Business Solutions
    KVP Business Solutions
    Agentforce · CLT · 2026
    Salesforce strategy

    CLT is the UI layer of the Agentforce platform

    The same pattern as Builder + MCP + Data Cloud — open, typed, reusable.

    B
    Builder
    Visual canvas for Topics, Actions & MCP tools.
    A
    Atlas reasoning
    Plan + tool-use across enterprise data.
    D
    Data Cloud
    Grounding with field-level retrieval.
    C
    CLT (new)
    Rich, interactive UI inside the conversational panel.
    kvpcorp.com5 / 6© KVP Business Solutions
    KVP Business Solutions
    Agentforce · CLT · 2026
    Make your agents look like your app

    Bring CLT into your Agentforce build — in weeks.

    KVP brings the Topics, the LWC pattern library, the typed payload schemas and the governance. You bring the use case.

    Read the blog: kvpcorp.com/blog/custom-lightning-types-agentforce
    Agentforce Fit diagnostic: kvpcorp.com/assessments/agentforce-fit
    Book a workshop: kvpcorp.com
    KVP
    Talk to us
    kvpcorp.com
    kvpcorp.com6 / 6© KVP Business Solutions
    Shareable infographic

    The CLT one-pager

    A single-image summary built for LinkedIn, X and WhatsApp. Download or share in one tap.

    KVP Business Solutions
    KVP · Agentforce Practice
    New from Salesforce

    Custom Lightning Types (CLT)

    Render rich, interactive Lightning Web Components inside the Agentforce conversational panel — typed payloads, branded UI, structured user input back to the agent.

    Six things to know
    Typed payloads
    Strongly-typed schema
    LWC rendering
    Any LWC is the renderer
    Agent-aware
    Events become new turns
    Native panel
    Service, Sales, Mobile, Embed
    Trust Layer
    Permissions + masking
    Reusable
    Across topics & channels
    Layer
    Before CLT
    With CLT
    Output
    Plain text / markdown bubble
    Branded LWC component
    Input
    Free-text the agent must parse
    Structured form / picker
    Actions
    Open a record in a new tab
    One-tap action inside panel
    Reuse
    Custom per assistant build
    Single typed component, many topics
    Customer benefits
    • Higher first-contact containment
    • On-brand panel UI, no tab-switching
    • Structured inputs → cleaner data
    • Reusable across Service, Sales, Mobile
    Developer flow
    • Define CLT metadata + schema
    • Build LWC renderer (@api payload)
    • Bind to an Agentforce Action response
    • Round-trip events as new turns
    CLT in the Agentforce stack
    Builder
    Visual canvas
    Atlas
    Reasoning
    Data Cloud
    Grounding
    CLT
    Panel UI
    © KVP Business Solutions · kvpcorp.com
    Read the full blog: /blog/custom-lightning-types-agentforce

    Ready to bring CLT into your Agentforce build?

    Talk to KVP's Agentforce pod about a focused 6–8 week sprint — typed CLT pattern library, LWC renderers, Data Cloud grounding and Agent Ops governance, in production.

    We value your privacy

    We use cookies to enhance your browsing experience, analyse site traffic, and personalise content. You can choose which cookies you'd like to allow. Learn more