> For a complete page index, fetch https://docs.synthflow.ai/llms.txt. For full documentation content, fetch https://docs.synthflow.ai/llms-full.txt. # Coding Options in Synthflow Synthflow's Conversational AI Platform (CAIP) provides **multiple coding options** to accommodate different technical skill levels and development preferences. Whether you're a business user building your first agent or a developer programmatically managing agents via API, Synthflow offers the right tools for your needs. ## Overview of Coding Options Synthflow supports four distinct coding paradigms: | Coding Option | Best For | Technical Level | Key Features | | --------------------------------------------- | -------------------------------------- | ------------------------ | ------------------------------------------------------- | | **Low-Code (Flow Designer + Custom Actions)** | Structured workflows, API integrations | Business users, analysts | Visual builder, GUI-based API configuration | | **No-Code (Single-Prompt)** | Quick setup, flexible conversations | Non-technical users | Natural language configuration | | **GenAI-Assisted** | Rapid prototyping, auto-generation | All levels | [Aurora](/aurora), automated flow and prompt generation | | **Pro-Code (Platform API)** | Programmatic agent management | Developers | REST API, scripting, automation | *** ## Low-Code: Flow Designer + Custom Actions Synthflow's **low-code paradigm** combines visual workflow building with GUI-based API integration, enabling business users to create sophisticated agents without writing code. ### What is Low-Code Development? Low-code development uses **declarative, high-level programming abstractions** via a dedicated graphical user interface (GUI). Instead of writing code, you configure behavior by connecting visual elements that represent logic, data collection, and actions. ### Flow Designer: Visual Workflow Building Build complex multi-step workflows by dragging and connecting nodes that represent specific conversation actions: * **Conversation Nodes**: Collect information from users (name, email, preferences) * **Branch Nodes**: Create conditional logic (if/else decisions) * **Custom Action Nodes**: Execute external API calls and integrations * **Message Nodes**: Deliver scripted statements * **Transfer Nodes**: Hand off to human agents * **Subflow Nodes**: Trigger reusable conversation modules * **Real-Time Booking Nodes**: Schedule appointments via calendar integrations Each node is configured through forms and dropdowns—no coding required. The visual interface makes it easy to see the entire conversation flow at a glance. **Documentation**: * [Getting Started with Flow Designer](/flow-designer) - Primary low-code interface guide * [Configure Conversation Nodes](/configure-step-nodes) - Conversation node configuration * [Configure Branch Nodes](/configure-branch-nodes) - Visual conditional logic * [Configure Message Node](/message-node) - Message node configuration * [Configure Jump Nodes](/configure-jump-nodes) - Flow control and loops * [Configure Call Transfer Node](/configure-call-transfer-node) - Human handoff configuration * [Multi-Agent System](/multi-agent-system) - Modular workflow architecture ### Key Capabilities **Deterministic Logic**: Conversations follow predictable, step-by-step paths defined by your flow design. This ensures: * Consistent behavior across all interactions * Audit trails for compliance scenarios * Easier debugging and troubleshooting * Guaranteed outcomes for critical workflows **Variable Collection**: Gather and store information during conversations using simple configuration: * Define variable names and types (string, number, boolean, list) * Set validation rules without code * Reference variables throughout your flow using `{variable_name}` syntax * Use collected data in branching logic and API calls **Branching Logic**: Create sophisticated decision trees visually: * Define conditions using dropdowns and forms * Route conversations based on user responses * Handle multiple scenarios without nested code * Test different paths independently **Multi-Agent System**: Break complex logic into modular, reusable subflows: * Create specialized sub-agents for specific tasks * Trigger subflows from multiple points in your main flow * Maintain organized, scalable conversation architecture * Update logic in one place and apply everywhere ### Custom Actions: Low-Code API Integration **Custom Actions** provide a GUI-based interface for integrating external APIs and services into your agents—no coding required. #### How Custom Actions Work Configure API integrations through visual forms and dropdowns: **1. Connect to the API** (GUI Configuration): * **Method**: Select HTTP method (GET, POST, PUT, PATCH, DELETE) from dropdown * **URL**: Enter API endpoint in text field * **Headers**: Add key-value pairs through form fields * **Authentication**: Toggle authentication and configure via GUI (API keys, OAuth, bearer tokens) * **Body**: Compose request body using form fields and variable references **2. Variables** (Low-Code Data Mapping): * Define variables with names, descriptions, and example values * System automatically extracts information from conversations * Reference variables in API requests using `` syntax * No scripting required—pure GUI configuration **3. Action Details** (Form-Based Setup): * **Name**: Define action name in text field * **Description**: Explain what the action does * **Speech**: Configure what agent says while action runs * **Timing**: Toggle to run before call starts **4. Use Results** (Prompt-Based Integration): * Write natural language prompt to incorporate API response * System automatically makes results available to agent * No code needed to parse or handle responses #### Example: CRM Integration (No Code Required) Configure a Salesforce contact creation through GUI: ``` Method: POST (selected from dropdown) URL: https://api.salesforce.com/v1/contacts (entered in text field) Headers (added via form): - Content-Type: application/json - Authorization: Bearer {api_token} Body (composed in GUI): { "firstName": , "lastName": , "phone": , "email": } Variables (defined in forms): - first_name: "The caller's first name" - last_name: "The caller's last name" - phone_number: "The caller's phone number" - email_address: "The caller's email address" ``` All configuration happens through forms—no code written. #### Custom Action Capabilities **External System Integration** (GUI-Based): * CRM systems (Salesforce, HubSpot, Zoho) * Databases (via REST APIs) * Payment processors (Stripe, PayPal) * Calendar systems (Google Calendar, Outlook) * Custom business APIs * Third-party services **Data Transformation** (Form-Based): * Variable extraction from conversations * Dynamic data injection into API requests * Response parsing and usage in conversations * Conditional logic based on API results **Authentication Methods** (Dropdown Selection): * API keys and bearer tokens * OAuth 2.0 flows * Basic authentication * Custom headers All configured through GUI forms without writing code. ### When to Use Low-Code Low-code options (Flow Designer + Custom Actions) are ideal for: * **Structured workflows** requiring deterministic behavior * **API integrations** with external systems (CRMs, databases, calendars) * **Compliance scenarios** needing audit trails (healthcare, finance, legal) * **Multi-step processes** like lead qualification, troubleshooting, onboarding * **Business users** who need powerful capabilities without coding * **Team collaboration** where non-developers build and maintain agents ### Low-Code Documentation **Flow Designer**: * [Getting Started with Flow Designer](/flow-designer) - Primary low-code interface * [Flow Designer vs Single-Prompt](/conversation-flow-vs-single-prompt) - Choosing approaches * [Publish Flow Designer](/publish-flow-designer) - Deploying flows **Nodes**: * [Configure Global Settings](/configure-global-settings) - Agent-wide configuration * [Configure Greeting Message Node](/configure-the-greeting-message-node) - Opening messages * [Configure Conversation Nodes](/configure-step-nodes) - Conversation nodes * [Configure Message Node](/message-node) - Message nodes * [Configure Branch Nodes](/configure-branch-nodes) - Conditional logic * [Configure Jump Nodes](/configure-jump-nodes) - Flow control * [Configure Custom Action Node](/configure-custom-action-node) - API integration nodes * [Configure Call Transfer Node](/configure-call-transfer-node) - Human handoff * [Configure Real-Time Booking Node](/configure-real-time-booking-node) - Calendar integration * [Configure End Node](/configure-the-end-node) - Call completion **Custom Actions**: * [About Custom Actions](/about-custom-actions) - Overview and capabilities * [Create a Custom Action](/about-custom-actions#create-and-configure-a-custom-action) - Step-by-step GUI configuration guide * [Use the Information Extractor](/use-the-information-extractor) - Variable extraction * [Dynamic Transfers](/dynamic-transfers) - Advanced transfer logic **Advanced Features**: * [Multi-Agent System](/multi-agent-system) - Modular subflows * [Variables](/variables) - Data collection patterns *** ## No-Code: Single-Prompt Agents **Single-Prompt Agents** represent Synthflow's no-code paradigm, where entire agent behaviors are configured using natural language prompts without any visual flow building or coding. ### What is No-Code Development? No-code development eliminates technical barriers entirely. Users describe what they want the agent to do in plain language, and the AI handles the conversation flow autonomously. ### How Single-Prompt Works Configure your agent by writing a single prompt that defines: * **Agent identity and role**: "You are Maya, a friendly real estate agent" * **Company context**: Background information about your business * **Conversation objectives**: What the agent should accomplish * **Tone and style**: How the agent should communicate * **Objection handling**: How to respond to common concerns The AI interprets these instructions and generates appropriate responses dynamically during conversations. No flow design, no nodes, no branching logic to configure—just natural language instructions. ### Key Capabilities **Natural Language Configuration**: Write instructions as if you're briefing a human colleague: ``` You are Jessica, an AI real estate agent for Majestic Estates. Your goal is to initiate dialogue with potential sellers about selling their home and arrange valuation meetings with our agents. Be warm, professional, and focus on the value we provide. ``` **Autonomous Conversation Flow**: The AI decides how to navigate conversations based on your prompt: * Asks relevant follow-up questions automatically * Adapts to unexpected user responses * Handles open-ended conversations naturally * No need to pre-define every possible path **Rapid Setup**: Get agents live in minutes: * No flow design required * No technical configuration * Immediate testing and iteration * Perfect for quick prototypes ### When to Use No-Code Single-Prompt Agents are ideal for: * **Quick setup** for small projects or MVPs * **Flexible conversations** where rigid structure isn't needed * **Simple Q\&A scenarios** like customer support or information lookup * **Non-technical users** who want to build agents without learning new tools * **Exploratory interactions** where conversation paths are unpredictable ### No-Code Documentation * [Single-Prompt Agents](/about-prompting) - Complete no-code guide with best practices * [Create an Agent](/create-an-agent) - Getting started with agent creation * [General Configuration](/general-configuration) - Agent settings and options * [Deploy Your Agent](/deploy-your-agent) - Publishing and deployment * [Call Configuration](/call-configuration) - Voice and call settings *** ## GenAI-Assisted Development Synthflow provides **[Aurora](/aurora)** to help you build agents faster, regardless of your chosen coding paradigm. Describe what you need in natural language and Aurora can scaffold prompts, flows, knowledge, and other workspace tasks from the main sidebar. **For Single-Prompt Agents**: * Describe your use case in plain language * Aurora generates a complete, optimized prompt * Refine the result in the agent editor to match your needs * Iterate quickly without starting from scratch **For Flow Designer**: * Describe the conversation flow you want to build * Aurora can generate a node-based flow to start from * Modify the generated flow using the visual editor * Add or remove nodes as needed ### Benefits of GenAI-Assisted Development * **Faster time-to-value**: Start with working agents in seconds * **Best practice guidance**: Generated configurations follow proven patterns * **Learning tool**: See how experts would structure your use case * **Iteration speed**: Regenerate with different requirements instantly ### When to Use GenAI-Assisted Tools * **Starting a new agent**: Get a solid foundation to build from * **Learning the platform**: See examples of well-structured configurations * **Rapid prototyping**: Test multiple approaches quickly * **Overcoming writer's block**: Get unstuck when you're not sure how to proceed * **Best practice discovery**: Learn optimal prompt structures and flow patterns ### GenAI-Assisted Documentation * [Aurora](/aurora) - Workspace assistant for building and operating agents * [About Prompting](/about-prompting) - Single-prompt agent configuration * [Flow Designer](/flow-designer) - Visual flow building and templates *** ## Pro-Code: Synthflow Platform API For developers, Synthflow provides a comprehensive **REST API** that enables programmatic access to the entire platform. Use scripting languages like Python, JavaScript, Java, or any HTTP-capable language to build, deploy, and manage agents programmatically. ### What is Pro-Code Development? Pro-code development uses **scripting and programming languages** to interact with Synthflow programmatically. Instead of using the GUI, developers write code to: * Create and configure agents * Manage calls and conversations * Access logs and analytics * Integrate Synthflow into larger automation workflows * Build custom tooling and dashboards ### Synthflow Platform API Capabilities The Platform API provides full programmatic control over Synthflow: #### Agent Management **Create Agents Programmatically**: ```python import requests response = requests.post( "https://api.synthflow.ai/v2/agents", headers={"Authorization": f"Bearer {API_KEY}"}, json={ "name": "Customer Support Agent", "prompt": "You are a helpful customer support agent...", "voice": "en-US-Neural2-F", "model": "gpt-4.1" } ) agent_id = response.json()["id"] ``` **Update Agent Configuration**: ```python requests.patch( f"https://api.synthflow.ai/v2/agents/{agent_id}", headers={"Authorization": f"Bearer {API_KEY}"}, json={ "model": "gpt-5-1", "prompt": "Updated prompt with new instructions..." } ) ``` **List and Query Agents**: ```python agents = requests.get( "https://api.synthflow.ai/v2/agents", headers={"Authorization": f"Bearer {API_KEY}"} ).json() ``` #### Call Management **Initiate Calls Programmatically**: ```javascript const response = await fetch('https://api.synthflow.ai/v2/calls', { method: 'POST', headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ agent_id: 'agent_123', phone_number: '+1234567890', variables: { customer_name: 'John Doe', account_id: 'ACC-12345' } }) }); ``` **Dynamic Prompt Injection**: ```javascript // Inject runtime context based on CRM data const customer = await crm.getCustomer(phoneNumber); await fetch('https://api.synthflow.ai/v2/calls', { method: 'POST', headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ agent_id: 'support_agent', phone_number: customer.phone, dynamic_prompt: ` Customer Tier: ${customer.tier} Lifetime Value: $${customer.ltv} Recent Issues: ${customer.recentIssues.join(', ')} Provide ${customer.tier} level support and reference their history. ` }) }); ``` **Retrieve Call Status**: ```python call_status = requests.get( f"https://api.synthflow.ai/v2/calls/{call_id}", headers={"Authorization": f"Bearer {API_KEY}"} ).json() ``` #### Logs and Analytics Access **Query Call Logs Programmatically**: ```python logs = requests.get( "https://api.synthflow.ai/v2/calls", headers={"Authorization": f"Bearer {API_KEY}"}, params={ "agent_id": agent_id, "start_date": "2025-01-01", "end_date": "2025-01-31", "limit": 100 } ).json() ``` **Extract Transcripts and Variables**: ```javascript const callDetails = await fetch( `https://api.synthflow.ai/v2/calls/${callId}`, { headers: { 'Authorization': `Bearer ${API_KEY}` }} ).then(r => r.json()); const transcript = callDetails.transcript; const collectedVariables = callDetails.variables; ``` #### Contact Management **Create Contacts Programmatically**: ```python contact = requests.post( "https://api.synthflow.ai/v2/contacts", headers={"Authorization": f"Bearer {API_KEY}"}, json={ "phone_number": "+1234567890", "first_name": "Jane", "last_name": "Smith", "email": "jane@example.com", "custom_fields": { "account_tier": "premium", "signup_date": "2025-01-15" } } ).json() ``` **Bulk Operations**: ```python # Upload contacts in bulk for campaigns contacts = [ {"phone_number": "+1111111111", "name": "Contact 1"}, {"phone_number": "+1222222222", "name": "Contact 2"}, # ... hundreds more ] for contact in contacts: requests.post( "https://api.synthflow.ai/v2/contacts", headers={"Authorization": f"Bearer {API_KEY}"}, json=contact ) ``` ### Webhook Integration (Pro-Code) **Inbound Webhooks**: Programmatic call routing and data injection ```python # Your server receives webhook before call starts @app.route('/inbound-webhook', methods=['POST']) def handle_inbound(): data = request.json caller_number = data['phone_number'] # Query your CRM customer = crm.lookup(caller_number) # Return dynamic configuration return { "agent_id": "vip_agent" if customer.is_vip else "standard_agent", "variables": { "customer_name": customer.name, "account_status": customer.status }, "dynamic_prompt": f"Customer tier: {customer.tier}" } ``` **Post-Call Webhooks**: Automated data processing ```javascript // Your server receives webhook after call completes app.post('/post-call-webhook', async (req, res) => { const { call_id, transcript, variables, outcome } = req.body; // Update CRM await crm.updateContact({ phone: variables.phone_number, lastCallDate: new Date(), callOutcome: outcome, notes: transcript }); // Trigger follow-up workflows if (outcome === 'appointment_booked') { await calendar.createEvent(variables.appointment_date); await email.sendConfirmation(variables.email); } res.status(200).send('OK'); }); ``` ### Advanced Pro-Code Use Cases #### Custom Dashboards and Analytics Build custom analytics dashboards by querying the API: ```python import pandas as pd import matplotlib.pyplot as plt # Fetch call data calls = requests.get( "https://api.synthflow.ai/v2/calls", headers={"Authorization": f"Bearer {API_KEY}"}, params={"start_date": "2025-01-01", "limit": 1000} ).json() # Analyze with pandas df = pd.DataFrame(calls) df['date'] = pd.to_datetime(df['created_at']) daily_calls = df.groupby(df['date'].dt.date).size() # Create visualizations daily_calls.plot(kind='line', title='Daily Call Volume') plt.savefig('call_volume.png') ``` #### Automated Testing and QA ```python # Automated regression testing test_cases = [ {"input": "I want to book an appointment", "expected_action": "booking"}, {"input": "What are your hours?", "expected_response_contains": "9am to 5pm"}, {"input": "Transfer me to sales", "expected_action": "transfer"} ] for test in test_cases: # Initiate test call call = requests.post( "https://api.synthflow.ai/v2/calls", headers={"Authorization": f"Bearer {API_KEY}"}, json={ "agent_id": agent_id, "phone_number": test_phone, "test_mode": True, "initial_input": test["input"] } ).json() # Verify outcome result = wait_for_call_completion(call["id"]) assert test["expected_action"] in result["actions"] ``` #### CI/CD Integration ```yaml # GitHub Actions workflow name: Deploy Agent Updates on: push: branches: [main] jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Update Agent Configuration run: | curl -X PATCH \ https://api.synthflow.ai/v2/agents/${{ secrets.AGENT_ID }} \ -H "Authorization: Bearer ${{ secrets.SYNTHFLOW_API_KEY }}" \ -H "Content-Type: application/json" \ -d @agent-config.json - name: Run Tests run: python test_agent.py ``` #### Multi-Tenant SaaS Integration ```javascript // Your SaaS platform creates isolated agents per customer async function provisionCustomerAgent(customer) { // Create dedicated agent const agent = await fetch('https://api.synthflow.ai/v2/agents', { method: 'POST', headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ name: `${customer.companyName} Support Agent`, prompt: generateCustomPrompt(customer), voice: customer.preferences.voice, model: customer.tier === 'enterprise' ? 'gpt-5-1' : 'gpt-4.1' }) }).then(r => r.json()); // Store agent ID in your database await db.customers.update(customer.id, { synthflow_agent_id: agent.id }); return agent; } ``` ### When to Use Pro-Code Pro-code Platform API access is essential for: * **Automation workflows**: Integrating Synthflow into larger systems * **Custom tooling**: Building internal dashboards, admin panels, or monitoring tools * **CI/CD pipelines**: Automated testing and deployment of agent updates * **Multi-tenant applications**: Programmatically managing agents per customer * **Data analysis**: Extracting and analyzing call data at scale * **Dynamic behavior**: Runtime customization based on external data * **Bulk operations**: Managing hundreds or thousands of agents/contacts * **Integration platforms**: Building Synthflow connectors for other tools ### Pro-Code Documentation **Platform API**: * [Platform API Reference](/api-reference) - Complete API documentation * [Authentication](/authentication) - API key management * [Agents API](/api-reference/platform-api/agents/create-assistant) - Agent management endpoints * [Calls API](/api-reference/platform-api/calls) - Call initiation and management * [Contacts API](/api-reference/platform-api/contacts) - Contact management * [Pre-call Variables](/variables#pre-call-variables) - Variable injection and extraction **Webhooks**: * [About Webhooks](/about-webhooks) - Webhook overview * [Inbound Webhook](/inbound-webhook) - Pre-call routing and data injection * [Inbound Webhook API](/inbound-webhook-api) - API specification * [Post-Call Webhook](/post-call-webhook) - Post-call automation * [Webhooks](/webhooks) - Complete webhook guide * [Webhooks Security](/webhooks-security) - HMAC validation **Advanced Features**: * [Dynamic Prompt Injection](/dynamic-prompt-injection) - Runtime prompt customization * [Use Action Variables in Inbound SIP Calls](/use-action-variables-in-inbound-sip-calls) - Advanced SIP integration *** ## Choosing the Right Coding Option ### Decision Framework **Start with Low-Code (Flow Designer + Custom Actions) if you need**: * ✅ Structured, predictable conversation paths * ✅ External API integrations (CRMs, databases, calendars) * ✅ Compliance and audit requirements * ✅ Multi-step workflows with clear decision points * ✅ Team collaboration with non-developers * ✅ Visual representation of conversation logic * ✅ GUI-based configuration without coding **Start with No-Code (Single-Prompt) if you need**: * ✅ Quick setup and rapid deployment * ✅ Flexible, open-ended conversations * ✅ Simple Q\&A or support scenarios * ✅ Non-technical team members building agents * ✅ Exploratory or creative interactions * ✅ Minimal configuration time **Use GenAI-Assisted tools when**: * ✅ Starting a new project and need a foundation * ✅ Learning the platform * ✅ Prototyping multiple approaches * ✅ Want to see best practice examples * ✅ Accelerating development time **Use Pro-Code (Platform API) when you need**: * ✅ Programmatic agent creation and management * ✅ Automation workflows and CI/CD pipelines * ✅ Custom dashboards and analytics * ✅ Multi-tenant SaaS applications * ✅ Bulk operations at scale * ✅ Runtime behavior customization via dynamic prompts * ✅ Integration with larger software systems * ✅ Webhook-based automation ### Combining Approaches Synthflow's coding options are **not mutually exclusive**. Most production agents combine multiple approaches: **Example: Enterprise Customer Support** * **Low-Code (Flow Designer)**: Main conversation structure and routing logic * **Low-Code (Custom Actions)**: Integration with Salesforce CRM and Zendesk * **GenAI-Assisted ([Aurora](/aurora))**: Initial flow generation and optimization * **Pro-Code (Platform API)**: Automated agent updates via CI/CD pipeline * **Pro-Code (Webhooks)**: Post-call data sync to data warehouse * **Pro-Code (Dynamic Prompts)**: Customer tier-based personalization **Example: Multi-Tenant SaaS Platform** * **Pro-Code (Platform API)**: Programmatic agent creation per customer * **Low-Code (Flow Designer)**: Template flows customized per tenant * **Low-Code (Custom Actions)**: Integration with customer-specific APIs * **Pro-Code (Webhooks)**: Usage tracking and billing automation This flexibility ensures you can use the right tool for each part of your agent's functionality and scale as your needs grow. *** ## Summary Synthflow provides comprehensive coding options that serve users across the technical spectrum: | Option | Interface | Primary Use Case | Skill Level | | -------------------------------------- | --------------------------- | ----------------------------------------- | ------------------------ | | **Low-Code (Flow Designer)** | Visual node-based builder | Structured workflows, deterministic logic | Business users, analysts | | **Low-Code (Custom Actions)** | GUI-based API configuration | External system integrations | Business users, analysts | | **No-Code (Single-Prompt)** | Natural language prompts | Quick, flexible conversational agents | Non-technical users | | **GenAI-Assisted ([Aurora](/aurora))** | AI-powered generation | Rapid prototyping, learning | All levels | | **Pro-Code (Platform API)** | REST API, scripting | Programmatic management, automation | Developers | ### Key Benefits by Paradigm **Low-Code Benefits**: * ✅ Visual workflow building without coding * ✅ GUI-based API integrations * ✅ Accessible to business users * ✅ Powerful capabilities without technical barriers * ✅ Team collaboration and transparency **No-Code Benefits**: * ✅ Fastest time to deployment * ✅ No learning curve * ✅ Natural language configuration * ✅ Perfect for simple use cases * ✅ Accessible to everyone **GenAI-Assisted Benefits**: * ✅ Accelerated development * ✅ Best practice examples * ✅ Learning tool for new users * ✅ Rapid iteration and prototyping **Pro-Code Benefits**: * ✅ Full programmatic control * ✅ Automation and CI/CD integration * ✅ Custom tooling and dashboards * ✅ Multi-tenant scalability * ✅ Enterprise system integration ### Platform-Wide Advantages By supporting multiple coding paradigms, Synthflow enables: * **Accessibility**: Non-technical users can build sophisticated agents through GUI interfaces * **Scalability**: Developers can programmatically manage thousands of agents via API * **Flexibility**: Choose the right tool for each requirement—visual for workflows, API for automation * **Collaboration**: Mixed-skill teams work together—business users build flows, developers handle integrations * **Growth Path**: Start with no-code, add low-code integrations, scale with pro-code automation ### Complete Documentation Index **Low-Code Resources**: * [Flow Designer](/flow-designer) * [About Custom Actions](/about-custom-actions) * [Create a Custom Action](/about-custom-actions#create-and-configure-a-custom-action) * [All Node Configuration Guides](/flow-designer) **No-Code Resources**: * [Single-Prompt Agents](/about-prompting) * [Create an Agent](/create-an-agent) * [General Configuration](/general-configuration) **Pro-Code Resources**: * [Platform API Reference](/api-reference) * [Webhooks Documentation](/webhooks) * [Dynamic Prompt Injection](/dynamic-prompt-injection) Whether you're a business analyst building your first agent with visual tools, a power user integrating external APIs through GUI forms, or a developer programmatically managing agents at scale via REST API, Synthflow provides the coding options you need to succeed.