Creating AI Agents

AI agents are autonomous assistants that can understand context, make decisions, and take actions on behalf of your team. Unlike simple automation rules that follow rigid if-then logic, agents use advanced language models to interpret requests, access knowledge bases, and intelligently respond to complex scenarios.

Why Use AI Agents

Before diving into creation, it's important to understand what makes AI agents powerful for your organization.

Intelligent Task Automation

Agents don't just follow scripts—they understand intent. If a team member asks "What tasks are blocking the Q1 launch?", an agent can analyze task dependencies, check due dates, identify bottlenecks, and provide a comprehensive answer. Traditional automation can't handle this kind of nuanced question.

24/7 Team Support

Your agent works around the clock, answering questions about project status, finding relevant documentation, and helping team members without waiting for human responses. This is especially valuable for distributed teams across time zones.

Knowledge Continuity

When team members leave or switch projects, institutional knowledge often leaves with them. Agents connected to knowledge bases preserve this information and make it accessible to everyone.

Consistent Responses

Agents follow the personality and guidelines you define, ensuring consistent communication across your organization. Whether responding to customers or internal teams, your agent maintains your company's voice and standards.

What You'll Need

Before creating an agent, ensure you have:

• Admin or Member role in your organization (Guests cannot create agents)
• Active subscription with AI credits available (check Settings → Billing)
• Clear use case defined (what will this agent do?)
• Knowledge sources ready if your agent needs specialized information (documents, guides, etc.)
• Integration permissions if your agent will connect to external tools (Slack, GitHub, etc.)

Agent Types Explained

When you create an agent, you'll choose from several specialized types. Each type comes with pre-configured instructions and recommended tools to help you get started faster.

Task Assistant

Best for: Teams managing projects, tracking work, and coordinating tasks

A Task Assistant helps users create, update, find, and organize tasks. It understands natural language requests like "Show me all high-priority bugs assigned to the frontend team" or "Create a task to update the API documentation with a due date of next Friday."

Default capabilities:

• Creating and updating tasks
• Searching and filtering tasks by project, assignee, status, or priority
• Setting due dates and reminders
• Adding comments and attachments
• Understanding task dependencies

Example use cases:

• Daily standup assistant that summarizes what each team member worked on yesterday
• Sprint planning helper that organizes backlog items by priority
• Project coordinator that ensures critical tasks have assignees

Recommended personality:

You are a helpful task management assistant. Be efficient and action-oriented.
When users ask about tasks, provide specific details (title, status, assignee,
due date). If creating tasks, confirm what you created and ask if they need
anything else added.

Code Reviewer

Best for: Development teams conducting code reviews, managing pull requests, and maintaining code quality

A Code Reviewer agent analyzes code changes, identifies potential issues, suggests improvements, and helps enforce coding standards. It connects to GitHub or other version control systems to access pull requests and commit history.

Default capabilities:

• Reviewing code changes in pull requests
• Checking for common bugs and security issues
• Suggesting performance improvements
• Enforcing style guidelines and best practices
• Tracking code review comments and resolutions

Example use cases:

• First-pass code review that catches syntax errors and common issues before human review
• Documentation checker that ensures all public functions have comments
• Security scanner that flags potential vulnerabilities

Recommended personality:

You are a senior developer conducting code reviews. Be constructive and educational
in your feedback. Point out issues clearly but always explain why something is
problematic and suggest specific improvements. When code looks good, acknowledge
what was done well.

Content Creator

Best for: Marketing teams, content writers, and anyone producing written materials

A Content Creator helps draft documents, generate ideas, refine copy, and maintain consistent brand voice. It can access your brand guidelines through knowledge bases and adapt content for different audiences.

Default capabilities:

• Drafting blog posts, emails, and social media content
• Generating content ideas and outlines
• Editing and improving existing copy
• Adapting tone for different audiences
• Checking content against brand guidelines

Example use cases:

• Blog post assistant that generates outlines based on keywords
• Email drafter that composes customer communications in your brand voice
• Social media manager that adapts long-form content into posts

Recommended personality:

You are a professional content writer and editor. Write in a clear, engaging style
that matches our brand voice (professional but approachable). When drafting content,
start with a brief outline for approval before writing the full piece. Always check
that content aligns with brand guidelines in the knowledge base.

Data Analyst

Best for: Teams working with metrics, reports, and data-driven decisions

A Data Analyst agent interprets task data, project metrics, and team performance statistics. It can answer questions about trends, generate reports, and identify patterns in your work data.

Default capabilities:

• Analyzing task completion rates and trends
• Calculating team velocity and capacity
• Identifying project bottlenecks
• Generating custom reports
• Comparing performance across time periods

Example use cases:

• Weekly report generator that summarizes team productivity metrics
• Bottleneck detector that identifies tasks blocking progress
• Capacity planner that estimates project timelines based on historical data

Recommended personality:

You are a data analyst focused on project metrics. Present findings clearly with
specific numbers and percentages. When showing trends, explain what the data means
and why it matters. If data suggests a problem, highlight it and recommend potential
solutions.

Custom

Best for: Specialized use cases not covered by preset types

Choose Custom when you have a unique use case or want complete control over your agent's behavior. You'll write all instructions from scratch rather than starting with a template.

Example custom agents:

• Customer support agent trained on your product documentation
• Meeting scheduler that coordinates team calendars
• Compliance checker that reviews tasks for regulatory requirements
• Onboarding assistant that guides new employees through setup

Building a custom agent: Since you're starting with a blank slate, be extra thorough with your instructions. Cover:

• What the agent does and doesn't do
• How it should communicate (formal vs. casual, brief vs. detailed)
• What information it needs before taking action
• How to handle uncertain or edge case scenarios
• Any constraints or limitations

Step-by-Step: Creating Your First Agent

Let's walk through creating an agent from start to finish. This example creates a Customer Support Agent, but the process is identical for any agent type.

1. Access the Agent Creation Panel

Navigate to your agents dashboard:

1. Click AI Agents in the left sidebar
2. Click Create Agent button (top right)
3. The creation panel opens on the right side

You'll see a blank agent form with several required fields marked with red asterisks.

2. Choose Agent Type and Name

Agent Name (required)

This appears to users when interacting with the agent. Choose something descriptive that clearly indicates the agent's purpose.

Good names:

• "Customer Support Assistant"
• "Development Team Helper"
• "Marketing Content Bot"
• "Project Planning Agent"

Avoid names like:

• "Agent 1" (too generic)
• "AI" (doesn't explain purpose)
• "Super Smart Helper" (too vague)

Tagline (required)

A one-sentence description that appears under the agent name. This helps team members quickly understand what the agent does.

Examples:

• "Answers customer questions about our product features and pricing"
• "Helps developers find tasks, review code, and manage pull requests"
• "Generates marketing content and social media posts"
• "Assists with sprint planning and task prioritization"

Agent Type (required)

Select the type that best matches your use case. For our customer support example, we'll choose Custom since there isn't a pre-built customer support type.

3. Write Clear Instructions

The Instructions field is the most important part of agent creation. This is where you define your agent's personality, capabilities, and boundaries.

Think of instructions as the agent's job description and training manual combined. The more specific and clear you are, the better your agent will perform.

Instruction Template for Customer Support Agent

Here's a comprehensive example you can adapt:

You are a customer support agent for [Your Company Name]. Your role is to help
customers understand our product, troubleshoot issues, and guide them to resources.

## What You Do

- Answer questions about product features, pricing, and account management
- Help troubleshoot common technical issues
- Guide users to relevant help documentation
- Create tasks for issues that require engineering review
- Escalate complex problems to human support team

## What You Don't Do

- Make promises about unreleased features
- Provide refunds or billing changes (direct to billing team)
- Share internal company information
- Make technical changes to customer accounts

## Communication Style

- Be friendly and empathetic - customers may be frustrated
- Use simple language, avoid technical jargon unless the customer uses it first
- Provide step-by-step instructions for troubleshooting
- Always acknowledge the customer's issue before providing solutions
- End responses by asking if they need additional help

## Handling Specific Scenarios

**If you're unsure about an answer:**
"I want to make sure I give you accurate information. Let me check with our team
and get back to you shortly. In the meantime, you might find [relevant doc link]
helpful."

**If a bug is reported:**
Create a task in the "Customer Reported Issues" project with:
- Customer description of the problem
- Steps to reproduce
- Expected vs. actual behavior
- Customer's account ID (if provided)

**If a feature request is made:**
"That's a great suggestion! I'll make sure our product team sees this request.
Many customers have asked for [related features], and we're actively evaluating
what to build next."

## Knowledge Base Usage

Before answering questions about features, check the knowledge base for:
- Latest product documentation
- Current pricing information
- Known issues and workarounds
- Troubleshooting guides

Always cite which document you referenced when possible.

Key Elements of Good Instructions

Define scope clearly

Explicitly state what the agent should and shouldn't do. This prevents the agent from attempting tasks outside its domain or making commitments it can't fulfill.

Specify communication style

Describe exactly how the agent should talk. Should it be formal or casual? Brief or detailed? Sympathetic or matter-of-fact? The agent will match whatever tone you define.

Provide example responses

Include sample responses for common scenarios. The agent learns your preferred phrasing and structure from these examples.

Reference knowledge bases

If you've uploaded documentation, tell the agent to check those sources before answering. This ensures accuracy and consistency with your official materials.

Handle edge cases

Describe what to do when the agent is uncertain, encounters an error, or faces a scenario not covered by instructions. Should it ask clarifying questions? Escalate to humans? Provide a standard disclaimer?

Instruction Examples for Other Agent Types

Task Assistant:

You are a task management assistant helping the engineering team stay organized.
When team members ask about tasks, provide specific information including assignee,
due date, and status. If creating tasks, confirm all required fields are filled
and ask if they want to add descriptions or attachments. Be concise—developers
prefer direct answers over lengthy explanations. When unsure which project a task
belongs to, always ask before creating it.

Content Creator:

You are a content writing assistant for our marketing team. Our brand voice is
professional but approachable—think friendly expert, not stuffy corporate. When
drafting content, start with a brief outline showing your planned structure and
key points. Wait for approval before writing the full piece. Check the brand
guidelines in your knowledge base for approved terminology, tone examples, and
topics to avoid. All content should be clear, scannable, and action-oriented.

Code Reviewer:

You are a code reviewer focused on React and TypeScript codebases. When reviewing
pull requests, check for: proper TypeScript typing (no 'any' types), React best
practices (hooks rules, component structure), potential performance issues, and
security concerns. Structure feedback into three sections: Critical Issues (must
fix), Suggestions (should consider), and Positive Notes (what was done well).
Always explain why something is an issue, don't just point it out. Reference our
coding standards document when relevant.

4. Upload Knowledge Base Documents (Optional)

Knowledge bases give your agent access to information beyond its training data. This is especially powerful for company-specific information, product details, internal processes, or any content that changes over time.

When to add a knowledge base:

• Your agent needs to answer questions about your specific product
• You have documentation, guides, or SOPs the agent should reference
• You want the agent to stay current with changing information
• The agent needs to cite authoritative sources

How to upload documents:

1. Click the Upload File button in the Knowledge base section
2. Select files from your computer (PDF, DOC, DOCX, or TXT)
3. Files upload and process automatically
4. Uploaded files appear in a table showing name, size, and upload time

Supported file types and limits:

• PDF documents (up to 10MB each)
• Word documents (.doc, .docx up to 10MB each)
• Text files (.txt up to 5MB each)
• Maximum 50 files per agent
• Files are chunked and indexed for efficient retrieval

Document preparation tips:

For best results, prepare your documents before uploading:

• Use clear headings and structure
• Keep information current and accurate
• Remove outdated or contradictory information
• Include specific examples where possible
• Use consistent terminology

Example knowledge base for customer support agent:

• Product feature documentation (what each feature does)
• Pricing and plan comparison guide
• Troubleshooting guides for common issues
• API documentation if you have developer customers
• Release notes for recent updates

Managing your knowledge base:

• Check the boxes next to files you want to remove
• Click Delete Selected to remove files
• Re-upload updated versions when documentation changes
• The agent automatically uses the latest version

5. Connect Tools and Integrations

Tools extend what your agent can actually do. Without tools, an agent can only have conversations—it can't create tasks, search GitHub, send Slack messages, or take actions in other systems.

Available tools depend on your integrations:

Only tools for integrations you've already connected appear in this section. If you want your agent to access GitHub, you must first set up the GitHub integration in Settings → Integrations.

Connecting tools to your agent:

1. Review the list of available tools (shows only your active integrations)
2. Click on tools you want the agent to use
3. Selected tools show a blue highlight and a dot indicator
4. Click Connect More to add additional integrations

Common tools and what they do:

Slack

• Send messages to channels
• Create threads and reply to messages
• Search message history
• Post notifications

When to enable: Your agent needs to notify teams, answer questions in Slack, or interact with users in channels.

GitHub

• Read pull requests and code changes
• Add review comments
• Check issue status
• Search repositories

When to enable: Code review agents, developer assistants, or any agent working with version control.

Notion

• Search Notion pages and databases
• Create and update pages
• Read workspace content

When to enable: Your agent needs to reference or update Notion documentation, project plans, or knowledge bases.

Google Docs

• Read document contents
• Search across documents
• Access shared files

When to enable: Content creation agents, documentation assistants, or agents that need to reference Google Drive files.

Google Sheets

• Read spreadsheet data
• Search for values
• Access sheet structure

When to enable: Data analysis agents, reporting assistants, or agents working with structured data.

Jira

• Search issues and projects
• Read issue details
• Check sprint information

When to enable: Project management agents, development coordinators, or agents tracking work in Jira.

Tool permissions and security:

Agents only access data within your organization's scope. An agent can't read private documents, access other organizations' data, or perform actions beyond the connected user's permissions.

Each tool uses the permissions of the integration connection. If your GitHub integration was connected by a user who can only read public repos, the agent inherits those same limitations.

Example tool configurations:

Customer Support Agent:

• Enable: Slack (for responding to support channels)
• Enable: Notion (for accessing help documentation)
• Skip: GitHub, Google Sheets (not needed for customer support)

Development Assistant:

• Enable: GitHub (for code review and issue tracking)
• Enable: Slack (for posting updates to dev channels)
• Enable: Jira (if you use Jira for project management)
• Skip: Google Docs (unless you store specs there)

Content Creator:

• Enable: Google Docs (for drafting and editing documents)
• Enable: Notion (for accessing content calendars and briefs)
• Enable: Slack (for collaborating with marketing team)
• Skip: GitHub, Jira (not relevant for content work)

6. Review and Create

Before clicking Create Agent, review everything one final time:

Checklist before creating:

• Agent name clearly describes its purpose
• Tagline accurately summarizes what the agent does
• Agent type matches your use case
• Instructions are comprehensive and specific
• Instructions include examples for common scenarios
• Knowledge base files are uploaded (if applicable)
• Relevant tools are connected
• No unnecessary tools are enabled

Creating the agent:

1. Click Create Agent button at the bottom
2. Agent processes and becomes available immediately
3. You'll return to the agents list view
4. Your new agent appears with an "Active" status indicator

What happens after creation:

Your agent is now live and available to your entire organization. Team members can:

• Find it in the AI Agents list
• Chat with it directly
• Mention it in task comments
• Use it in workflows and automations

The agent starts learning from interactions. Over time, it becomes more effective as it encounters more scenarios and questions.

Testing Your Agent

After creation, thoroughly test your agent before your team relies on it.

Basic Functionality Testing

Test 1: Simple Question

Open the agent and ask a basic question within its scope.

Example for customer support agent: "What features are included in the Pro plan?"

The agent should reference your knowledge base and provide accurate information.

Test 2: Action Request

Ask the agent to perform an action using one of its connected tools.

Example for task assistant: "Create a task called 'Update homepage copy' assigned to me with high priority."

Verify the agent actually creates the task correctly.

Test 3: Unknown Information

Ask about something the agent shouldn't know or can't do.

Example: "What will the company revenue be next quarter?"

The agent should acknowledge it doesn't have this information rather than making something up.

Test 4: Unclear Request

Give an ambiguous instruction that needs clarification.

Example: "I need help with that thing from yesterday."

The agent should ask clarifying questions rather than guessing.

Edge Case Testing

Test for hallucination:

Ask a question that sounds plausible but isn't in your knowledge base. The agent should say it doesn't know rather than inventing an answer.

Test tool usage:

If your agent has multiple tools, ensure it chooses the right tool for each task. An agent with both Slack and GitHub shouldn't try to send Slack messages when asked to review code.

Test error handling:

Try to trigger an error (like creating a task without a required field). The agent should handle it gracefully and explain what's needed.

Test personality consistency:

Ask the same question multiple times in different ways. The agent should maintain consistent tone and style across all responses.

Load Testing for Teams

Once basic functionality works:

1. Share the agent with a small pilot group (3-5 people)
2. Ask them to use it for real work scenarios
3. Collect feedback on accuracy, helpfulness, and usability
4. Review the agent's response history to identify patterns
5. Make adjustments to instructions or tools based on feedback

Common Issues When Creating Agents

Issue: Agent provides generic or unhelpful answers

Likely cause: Instructions are too vague or don't include enough examples.

Solution: Expand your instructions with specific scenarios and example responses. Show the agent exactly how you want it to respond to common questions.

Issue: Agent can't access information from knowledge base

Likely cause: Document format isn't supported, file is too large, or content isn't well-structured.

Solution: Check that files are under size limits and in supported formats (PDF, DOC, DOCX, TXT). Add clear headings and structure to documents. Test by asking the agent a question that definitely appears in one of your documents.

Issue: Agent makes up information (hallucinates)

Likely cause: Instructions don't emphasize checking knowledge base first, or the agent is trying to be helpful beyond its capabilities.

Solution: Add clear instructions about when to say "I don't know." Example: "If you're not certain about an answer and can't find it in the knowledge base, say so. Never guess or make up information."

Issue: Agent tries to do tasks outside its scope

Likely cause: Instructions don't clearly define boundaries.

Solution: Add a "What You Don't Do" section to instructions that explicitly lists out-of-scope activities.

Issue: Tool connections don't work

Likely cause: Integration isn't properly configured or lacks necessary permissions.

Solution: Go to Settings → Integrations and verify the integration is connected and authorized. Re-authorize if needed. Check that the connecting user has appropriate permissions for the actions the agent needs to perform.

Issue: Agent responses are too long or too brief

Likely cause: Communication style isn't specified in instructions.

Solution: Add specific guidance about response length. Examples: "Keep responses under 3 sentences when possible" or "Provide detailed explanations with examples."

Best Practices for Agent Creation

Start narrow, expand later

Create agents for specific, well-defined use cases rather than trying to build one agent that does everything. A specialized agent performs better than a generalist.

Iterate based on real usage

Your first version won't be perfect. Monitor how people use the agent, identify gaps or mistakes, and refine instructions accordingly.

Version your instructions

Before making major changes to an agent, save a copy of current instructions. This makes it easy to revert if new instructions cause problems.

Use consistent terminology

If your team calls something "projects," don't use "workspaces" in your agent instructions. Match the language your team actually uses.

Test with real data

Don't just test with simple examples. Use actual questions from your team, real task data, and genuine scenarios you encounter daily.

Document your agents

Create a simple guide explaining what each agent does, when to use it, and what it can't do. Share this with your team so they know how to work effectively with agents.

Monitor and maintain

Agents aren't set-and-forget. Review usage monthly, update knowledge bases when documentation changes, and refine instructions as your needs evolve.

Real-World Examples

Example 1: Support Ticket Triage Agent

Organization: SaaS company with 50 employees Problem: Support tickets piling up, unclear priorities, manual routing

Agent Configuration:

• Name: "Support Triage Bot"
• Type: Custom
• Tools: Slack, Notion
• Knowledge Base: Product docs, known issues, escalation policies

Instructions excerpt:

Analyze incoming support tickets and categorize them:

Priority Assignment:
- P0 (Critical): Service outage, security issue, payment processing broken
- P1 (High): Feature not working for multiple users, account access issues
- P2 (Medium): Feature requests, single-user bugs, questions
- P3 (Low): Documentation requests, general feedback

Routing Rules:
- Technical bugs → Engineering team
- Billing questions → Finance team
- Account/access issues → Customer success
- Feature requests → Product team

Create a task with:
- Clear title summarizing the issue
- Full ticket text in description
- Assigned team based on routing rules
- Priority based on urgency
- Link back to original ticket

Results:

• 80% of tickets automatically triaged in under 30 seconds
• Average response time reduced from 4 hours to 45 minutes
• Support team focuses on complex issues instead of categorization

Example 2: Code Review Assistant

Organization: Engineering team of 25 developers Problem: Code reviews taking too long, inconsistent standards

Agent Configuration:

• Name: "Code Quality Bot"
• Type: Code Reviewer
• Tools: GitHub, Slack
• Knowledge Base: Coding standards, security guidelines, common pitfalls

Instructions excerpt:

Review pull requests for:

1. Code Quality:
- TypeScript: No 'any' types, proper interface definitions
- React: Proper hook usage, component structure
- Testing: New code has corresponding tests

2. Security:
- No hardcoded secrets or API keys
- Proper input validation
- SQL injection prevention

3. Performance:
- Unnecessary re-renders
- Large bundle sizes
- N+1 query patterns

Provide feedback in three sections:
- Critical Issues (must fix before merge)
- Suggestions (should consider)
- Positive Notes (what was done well)

Be constructive and educational. Explain WHY something is an issue.

Results:

• 60% fewer critical issues reaching production
• Developers learn best practices from agent feedback
• Human reviewers focus on architecture and logic instead of syntax

Example 3: Content Calendar Manager

Organization: Marketing team producing 20+ pieces of content monthly Problem: Missed deadlines, unclear ownership, inconsistent publishing

Agent Configuration:

• Name: "Content Scheduler"
• Type: Task Assistant
• Tools: Google Docs, Slack, Notion
• Knowledge Base: Content calendar template, style guide, SEO guidelines

Instructions excerpt:

Manage monthly content production:

Content Creation Workflow:
1. Generate tasks for each content piece
2. Set milestone dates:
- Research/outline: 10 days before publish
- First draft: 7 days before publish
- Review: 3 days before publish
- Final edits: 1 day before publish
- Publish: On scheduled date

3. Auto-assign based on:
- Topic expertise (from knowledge base)
- Current workload
- Content type specialization

4. Send reminders:
- 2 days before each milestone
- Daily for overdue items
- Weekly summary of upcoming deadlines

5. Quality checks:
- SEO keywords included
- Style guide compliance
- Image assets prepared

Results:

• 95% on-time content publication (up from 70%)
• Clear ownership and accountability
• Proactive reminders prevent last-minute rushes

Next Steps

Now that you've created your first agent:

1. Configure advanced settings - Learn about model selection, temperature, and reasoning effort in Agent Configuration

2. Build your knowledge base - Deep dive into knowledge base optimization in Knowledge Base Management

3. Monitor performance - Track your agent's effectiveness in Agent Analytics

4. Use agents in workflows - Integrate agents into automated workflows in Flow Builder