How to Build a Custom Pluggin With the Agent Builder

A Custom Pluggin is a user-defined AI agent built within Pluggin.ai's Agent Builder that is configured with a specific system prompt, selected integrations, custom logic, and tailored behavior to handle a business process unique to your organization. Unlike Pluggin.ai's pre-built agents that cover common workflows out of the box, Custom Pluggins let you create agents that match your exact operational requirements -- available on the Scale plan at $249/mo.

When You Need a Custom Pluggin

Pluggin.ai's library of pre-built agents covers the most common business workflows: lead qualification, content publishing, meeting scheduling, invoice processing, and more. These agents work well for standardized processes.

But every business has workflows that are uniquely its own. Your sales qualification criteria are different from your competitor's. Your content approval process has steps that no template anticipated. Your financial reconciliation involves custom data sources and business rules that off-the-shelf agents cannot address.

Custom Pluggins exist for these situations. They give you full control over:

• System prompt and personality: Define exactly how the agent reasons, what tone it uses, and what rules it follows.
• Integration selection: Choose from any of the 17 available connectors (Apollo, HubSpot, Stripe, Gmail, Google Calendar, Slack, Notion, Brave Search, Perplexity, Webflow, Beehiiv, Ahrefs, SEMrush, Clay, Ghost, Calendly, Google Search Console).
• Input/output schemas: Define exactly what data the agent expects and what it produces.
• Behavioral constraints: Set guardrails on what the agent can and cannot do.
• Chain integration: Plug the custom agent into multi-agent chains alongside pre-built agents.

The Agent Builder Interface

The Agent Builder is accessible from the Pluggin.ai dashboard under the "Custom Pluggins" section. It is a structured form-based interface, not a code editor. You do not need programming experience to build a Custom Pluggin.

The builder is organized into five sections:

1. Identity and Purpose

This is where you name your agent and define its high-level purpose. The name should be descriptive and specific. "Q4 Enterprise Deal Reviewer" is better than "Sales Agent."

You also write the agent's system prompt here. The system prompt is the most important part of any Custom Pluggin. It tells the agent who it is, what it does, what rules it follows, and how it should reason about tasks.

Tips for writing effective system prompts:

• Be explicit about the agent's role and scope. Tell it what it should do and what it should not do.
• Include your business context. If the agent needs to know your ICP criteria, pricing tiers, or internal terminology, put that information in the system prompt.
• Define output format expectations. If you want the agent to produce structured JSON, a formatted summary, or a specific report template, include an example in the prompt.
• Set behavioral boundaries. If the agent should never contact a customer directly or never modify financial records without approval, state that clearly.

2. Integration Configuration

Select which connectors the agent can access. The builder displays all connected integrations in your workspace. Toggle on the ones this agent needs.

For each integration, you can optionally set permission scopes. For example, you might give a reporting agent read-only access to Stripe while giving a subscription management agent both read and write access.

3. Input Schema

Define what data the agent receives when triggered. This can be:

• Event-driven: Data from a trigger event (e.g., a new HubSpot contact, a Stripe payment event, a Slack message).
• Manual: Data passed in when a user manually invokes the agent.
• Chain-passed: Data from a preceding agent in a multi-agent chain.

The input schema uses a simple field definition format: field name, data type (text, number, boolean, array, object), and whether the field is required or optional.

4. Output Schema

Define what the agent produces. This matters most when the agent is part of a chain, because downstream agents and conditions depend on structured output.

You can define:

• Structured fields: Specific data points the agent must output (e.g., lead_score, recommended_action, summary).
• Free-form output: A text block for agents that produce reports or summaries.
• Hybrid: Structured fields plus a free-form section.

5. Testing and Deployment

The builder includes a built-in test console. You can provide sample input data and run the agent in test mode to see its output, reasoning trace, and integration calls.

Once satisfied, click "Deploy." The agent becomes available in your workspace and can be added to chains, triggered by events, or invoked manually.

Walkthrough: Building a Custom Deal Reviewer

Let us build a concrete example -- a Custom Pluggin that reviews enterprise deals before they go to the pricing committee.

Define the Identity

• Name: Enterprise Deal Reviewer
• System prompt: "You are an enterprise deal reviewer for [Company]. Your role is to analyze proposed deals and produce a structured assessment. Evaluate each deal against the following criteria: annual contract value (must exceed $50K), customer fit with our ICP (B2B SaaS companies with 200+ employees), competitive positioning (identify if a competitor is involved), and discount justification (any discount above 15% requires detailed justification). Output a structured review with a recommendation: Approve, Request Changes, or Escalate."

Configure Integrations

Toggle on:

• HubSpot -- to pull deal data, associated contacts, and company information.
• Slack -- to post the review summary to the #deal-review channel.
• Google Calendar -- to check if a pricing committee meeting is scheduled within the next 5 business days.

Define Input Schema

• deal_id (text, required) -- The HubSpot deal ID to review.
• submitted_by (text, required) -- The name of the sales rep who submitted the deal.
• urgency (text, optional) -- "standard" or "expedited."

Define Output Schema

• recommendation (text) -- "Approve," "Request Changes," or "Escalate."
• risk_factors (array) -- List of identified risks.
• discount_analysis (text) -- Assessment of any proposed discounts.
• summary (text) -- A two-paragraph executive summary.
• next_steps (text) -- Recommended actions for the sales rep.

Test and Deploy

Provide a real HubSpot deal ID as test input. Run the agent. Review its output. Adjust the system prompt if the reasoning is off or the output format needs refinement. Once the output meets your standards, deploy.

Integrating Custom Pluggins Into Chains

Custom Pluggins work identically to pre-built agents when placed in chains. You can:

• Insert a Custom Pluggin at any position in a sequential chain.
• Use a Custom Pluggin's output to drive conditional branching.
• Run multiple Custom Pluggins in parallel within a parallel execution chain.
• Combine Custom Pluggins with pre-built agents in the same chain.

This composability is a core design principle in Pluggin.ai. There is no difference in capability between custom and pre-built agents once deployed.

Scale Plan Requirements

The Custom Pluggin builder is available on the Scale plan at $249/mo. This plan includes:

• Unlimited Custom Pluggins
• Access to all 17 connectors
• Advanced chain templates
• Priority support
• Workspace collaboration features for teams

If you are on a lower-tier plan, you can still use all pre-built agents and standard chains. The Scale plan adds the builder for organizations that need bespoke automation beyond what the standard library covers.

Best Practices

Iterate on your system prompt. The first version of a system prompt is rarely the best. Test, review the agent's reasoning, and refine. Most teams go through three to five iterations before a Custom Pluggin is production-ready.

Scope narrowly. A Custom Pluggin that tries to do everything will do nothing well. Build agents that handle one specific process and chain them together for complex workflows.

Document your Custom Pluggins. Use the description field in the builder to explain what the agent does, what it expects, and any known limitations. Future team members will thank you.

Version your system prompts. When you update a Custom Pluggin's system prompt, note what changed and why. This helps with troubleshooting if the agent's behavior shifts unexpectedly.

Frequently Asked Questions

Can I share a Custom Pluggin with other team members?

Yes. Custom Pluggins created in a workspace are available to all workspace members on the Scale plan. Team members can use the agent in their chains, though only workspace admins can edit the agent's configuration.

Is there a limit to how many Custom Pluggins I can create?

No. The Scale plan includes unlimited Custom Pluggins. Build as many as your workflows require.

Can I export or import Custom Pluggin configurations?

Currently, Custom Pluggins are managed within the Pluggin.ai workspace. Export and import functionality is on the product roadmap. For now, we recommend documenting your system prompts and schemas externally as a backup.

How do Custom Pluggins handle errors?

Custom Pluggins follow the same error handling as pre-built agents. If an integration call fails or the agent encounters an issue it cannot resolve, it logs the error, pauses execution, and notifies you through your configured alert channel (Slack, email, or in-app notification).

Can I use Custom Pluggins with approval gates?

Absolutely. Approval gates can be placed before, after, or around any Custom Pluggin in a chain. This is especially important for Custom Pluggins that perform write operations on critical systems like Stripe or HubSpot. See our approval gates guide for details.