Agentforce Builder Studio
Building AI agents with natural language — before “vibe coding” was a thing
For decades, building software has meant writing code or configuring complex systems.
In late 2024, our team began exploring a different possibility:
What if software could be created simply by describing what you want?
This idea became Agentforce Builder Studio — an exploration into conversational interfaces for creating AI agents, applications, automations, and workflows.
Months before the industry began calling this approach “vibe coding,” we were prototyping how natural language could become the primary interface for building software.
Working through a series of rapid design sprints, we developed prototypes that reimagined agent creation as a collaborative conversation between humans and AI.
I led the sprint effort across a small cross-disciplinary design team, helping define the early direction for conversational agent creation inside Salesforce.
Role: Senior Director of Design
Team: 3–5 designers
Scope: Early product exploration that informed Agentforce Builder
Timeline: Fall 2024 (3 rapid design sprints)
Focus: Conversational interfaces for AI agent creation
The Problem → The Idea
The Problem
Enterprise automation tools are powerful, but building anything meaningful often requires navigating dozens of configuration screens, flows, and scripts.
Even experienced teams struggle to prototype ideas quickly.
At the same time, large language models were unlocking a new paradigm: software defined by intent rather than configuration.
The Idea
Instead of navigating menus to build agents, what if users could simply describe what they want?
“Build a customer service agent that helps answer product questions and schedule service calls.”
The system would then generate:
• the agent structure
• suggested tools and integrations
• workflows and automation logic
• an initial configuration
In other words: describe the system → the system builds itself.
Start conversationally
Traditional enterprise builders start with configuration. Agentforce Builder Studio started with conversation.
Users describe what they want to create:
“Build an agent that helps sales teams qualify inbound leads and schedule follow-ups.”
The system then generates:
• a unified project structure
• suggested tools and integrations
• workflows and automation logic
• appropriate guardrails and next best actions
• an initial configuration
Instead of navigating configuration menus, the builder gathers intent and scaffolds the system automatically.
A natural-language generative canvas
One of the key ideas was shifting from static configuration screens to a living, AI-generated product canvas.
As the conversation evolves, the interface dynamically generates structured artifacts such as:
• agent goals
• behaviors
• integrations
• automation logic
• workflow components
Rather than filling out configuration forms, users shape the system through conversation.
The experience feels less like programming and more like co-designing with the platform.
Built for collaborative work
Agents rarely exist in isolation — they are created, refined, and operated by teams.
We explored ways for agent projects to integrate directly with the tools people already use, including Slack, GitHub, and email.
Rather than forcing collaboration inside a single interface, projects could be shared, discussed, and iterated on from those environments while the builder stayed synchronized in the background.
This allowed teams to collaborate with agents from wherever they already work, while the system continuously updated the project inside Agentforce Builder.
Automatic project scaffolding
Creating a new project didn’t just generate an agent — it scaffolded the entire working environment needed to build and collaborate around it.
Behind the scenes, the system automatically created:
• a Git repository
• a Slack channel for collaboration
• an agent configuration and canvas
• a preview link to test and share the experience
Teams could immediately begin interacting with the agent and refining the project together
Updates made through Slack conversations or shared documents synchronized back into the builder automatically.
The goal was to remove the overhead of project setup so teams could focus on shaping the agent itself.
Design principles
As the concepts evolved through rapid sprints, several design principles emerged that guided the direction of the builder.
Intent before configuration
Users describe outcomes first. Structure emerges from the system interpreting intent.
Progressive complexity
The interface reveals deeper configuration only when necessary, keeping the initial experience simple.
Conversation as collaboration
The system behaves less like a tool and more like a collaborator helping shape the agent.
Artifacts over prompts
The conversation produces structured artifacts — goals, workflows, tools — not just text responses.
Leadership & impact
I led the design effort across these sprints, coordinating a small cross-disciplinary team of designers working closely with product and engineering.
The work was developed rapidly through short sprint cycles and presented to senior leadership across Salesforce.
Key stakeholders included:
• Adam Evans — EVP & GM of AI
• Kat Holmes — Chief Design Officer
• Executive product leadership across Salesforce
These explorations helped shape early thinking around conversational agent creation within the Agentforce platform.
Elements of the concept later appeared in the first phase of Agentforce Builder, which launched publicly at Dreamforce 2025.
The work demonstrated how enterprise teams could begin creating AI systems through natural language and intent rather than configuration and code.
This work explored an emerging shift from configuring software to describing it — a pattern that is now rapidly becoming the default model for building AI systems.
What began as a rapid design exploration anticipated a broader industry shift toward intent-driven software creation.