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	AI-powered Co-Pilot, automated flow creation
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 - Primary low-code interface guide
Configure Conversation Nodes - Conversation node configuration
Configure Branch Nodes - Visual conditional logic
Configure Message Node - Message node configuration
Configure Jump Nodes - Flow control and loops
Configure Call Transfer Node - Human handoff configuration
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 <variable_name> 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": <first_name>,
  "lastName": <last_name>,
  "phone": <phone_number>,
  "email": <email_address>
}
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 - Primary low-code interface
Flow Designer vs Single-Prompt - Choosing approaches
Publish Flow Designer - Deploying flows

Nodes:

Configure Global Settings - Agent-wide configuration
Configure Greeting Message Node - Opening messages
Configure Conversation Nodes - Conversation nodes
Configure Message Node - Message nodes
Configure Branch Nodes - Conditional logic
Configure Jump Nodes - Flow control
Configure Custom Action Node - API integration nodes
Configure Call Transfer Node - Human handoff
Configure Real-Time Booking Node - Calendar integration
Configure End Node - Call completion

Custom Actions:

About Custom Actions - Overview and capabilities
Create a Custom Action - Step-by-step GUI configuration guide
Use the Information Extractor - Variable extraction
Dynamic Transfers - Advanced transfer logic

Advanced Features:

Multi-Agent System - Modular subflows
Collect 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 - Complete no-code guide with best practices
Create an Agent - Getting started with agent creation
General Configuration - Agent settings and options
Deploy Your Agent - Publishing and deployment
Call Configuration - Voice and call settings

GenAI-Assisted Development

Synthflow provides GenAI-assisted tools that use artificial intelligence to help you build agents faster, regardless of your chosen coding paradigm.

Co-Pilot: AI-Powered Agent Generation

The Co-Pilot feature automatically generates agent configurations based on your requirements:

For Single-Prompt Agents:

Describe your use case in plain language
Co-Pilot generates a complete, optimized prompt
Refine the auto-generated prompt to match your needs
Iterate quickly without starting from scratch

For Flow Designer:

Describe the conversation flow you want to build
Co-Pilot generates a complete node-based flow automatically
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

About Prompting - Includes Co-Pilot usage for prompt generation
Flow Designer - Template library and AI assistance

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:

1 import requests
2 
3 response = requests.post(
4     "https://api.synthflow.ai/v2/agents",
5     headers={"Authorization": f"Bearer {API_KEY}"},
6     json={
7         "name": "Customer Support Agent",
8         "prompt": "You are a helpful customer support agent...",
9         "voice": "en-US-Neural2-F",
10         "model": "gpt-4o"
11     }
12 )
13 agent_id = response.json()["id"]

Update Agent Configuration:

1 requests.patch(
2     f"https://api.synthflow.ai/v2/agents/{agent_id}",
3     headers={"Authorization": f"Bearer {API_KEY}"},
4     json={
5         "model": "gpt-5-1",
6         "prompt": "Updated prompt with new instructions..."
7     }
8 )

List and Query Agents:

1 agents = requests.get(
2     "https://api.synthflow.ai/v2/agents",
3     headers={"Authorization": f"Bearer {API_KEY}"}
4 ).json()

Call Management

Initiate Calls Programmatically:

1 const response = await fetch('https://api.synthflow.ai/v2/calls', {
2   method: 'POST',
3   headers: {
4     'Authorization': `Bearer ${API_KEY}`,
5     'Content-Type': 'application/json'
6   },
7   body: JSON.stringify({
8     agent_id: 'agent_123',
9     phone_number: '+1234567890',
10     variables: {
11       customer_name: 'John Doe',
12       account_id: 'ACC-12345'
13     }
14   })
15 });

Dynamic Prompt Injection:

1 // Inject runtime context based on CRM data
2 const customer = await crm.getCustomer(phoneNumber);
3 
4 await fetch('https://api.synthflow.ai/v2/calls', {
5   method: 'POST',
6   headers: {
7     'Authorization': `Bearer ${API_KEY}`,
8     'Content-Type': 'application/json'
9   },
10   body: JSON.stringify({
11     agent_id: 'support_agent',
12     phone_number: customer.phone,
13     dynamic_prompt: `
14       Customer Tier: ${customer.tier}
15       Lifetime Value: $${customer.ltv}
16       Recent Issues: ${customer.recentIssues.join(', ')}
17       
18       Provide ${customer.tier} level support and reference their history.
19     `
20   })
21 });

Retrieve Call Status:

1 call_status = requests.get(
2     f"https://api.synthflow.ai/v2/calls/{call_id}",
3     headers={"Authorization": f"Bearer {API_KEY}"}
4 ).json()

Logs and Analytics Access

Query Call Logs Programmatically:

1 logs = requests.get(
2     "https://api.synthflow.ai/v2/calls",
3     headers={"Authorization": f"Bearer {API_KEY}"},
4     params={
5         "agent_id": agent_id,
6         "start_date": "2025-01-01",
7         "end_date": "2025-01-31",
8         "limit": 100
9     }
10 ).json()

Extract Transcripts and Variables:

1 const callDetails = await fetch(
2   `https://api.synthflow.ai/v2/calls/${callId}`,
3   { headers: { 'Authorization': `Bearer ${API_KEY}` }}
4 ).then(r => r.json());
5 
6 const transcript = callDetails.transcript;
7 const collectedVariables = callDetails.variables;

Contact Management

Create Contacts Programmatically:

1 contact = requests.post(
2     "https://api.synthflow.ai/v2/contacts",
3     headers={"Authorization": f"Bearer {API_KEY}"},
4     json={
5         "phone_number": "+1234567890",
6         "first_name": "Jane",
7         "last_name": "Smith",
8         "email": "jane@example.com",
9         "custom_fields": {
10             "account_tier": "premium",
11             "signup_date": "2025-01-15"
12         }
13     }
14 ).json()

Bulk Operations:

1 # Upload contacts in bulk for campaigns
2 contacts = [
3     {"phone_number": "+1111111111", "name": "Contact 1"},
4     {"phone_number": "+1222222222", "name": "Contact 2"},
5     # ... hundreds more
6 ]
7 
8 for contact in contacts:
9     requests.post(
10         "https://api.synthflow.ai/v2/contacts",
11         headers={"Authorization": f"Bearer {API_KEY}"},
12         json=contact
13     )

Webhook Integration (Pro-Code)

Inbound Webhooks: Programmatic call routing and data injection

1 # Your server receives webhook before call starts
2 @app.route('/inbound-webhook', methods=['POST'])
3 def handle_inbound():
4     data = request.json
5     caller_number = data['phone_number']
6     
7     # Query your CRM
8     customer = crm.lookup(caller_number)
9     
10     # Return dynamic configuration
11     return {
12         "agent_id": "vip_agent" if customer.is_vip else "standard_agent",
13         "variables": {
14             "customer_name": customer.name,
15             "account_status": customer.status
16         },
17         "dynamic_prompt": f"Customer tier: {customer.tier}"
18     }

Post-Call Webhooks: Automated data processing

1 // Your server receives webhook after call completes
2 app.post('/post-call-webhook', async (req, res) => {
3   const { call_id, transcript, variables, outcome } = req.body;
4   
5   // Update CRM
6   await crm.updateContact({
7     phone: variables.phone_number,
8     lastCallDate: new Date(),
9     callOutcome: outcome,
10     notes: transcript
11   });
12   
13   // Trigger follow-up workflows
14   if (outcome === 'appointment_booked') {
15     await calendar.createEvent(variables.appointment_date);
16     await email.sendConfirmation(variables.email);
17   }
18   
19   res.status(200).send('OK');
20 });

Advanced Pro-Code Use Cases

Custom Dashboards and Analytics

Build custom analytics dashboards by querying the API:

1 import pandas as pd
2 import matplotlib.pyplot as plt
3 
4 # Fetch call data
5 calls = requests.get(
6     "https://api.synthflow.ai/v2/calls",
7     headers={"Authorization": f"Bearer {API_KEY}"},
8     params={"start_date": "2025-01-01", "limit": 1000}
9 ).json()
10 
11 # Analyze with pandas
12 df = pd.DataFrame(calls)
13 df['date'] = pd.to_datetime(df['created_at'])
14 daily_calls = df.groupby(df['date'].dt.date).size()
15 
16 # Create visualizations
17 daily_calls.plot(kind='line', title='Daily Call Volume')
18 plt.savefig('call_volume.png')

Automated Testing and QA

1 # Automated regression testing
2 test_cases = [
3     {"input": "I want to book an appointment", "expected_action": "booking"},
4     {"input": "What are your hours?", "expected_response_contains": "9am to 5pm"},
5     {"input": "Transfer me to sales", "expected_action": "transfer"}
6 ]
7 
8 for test in test_cases:
9     # Initiate test call
10     call = requests.post(
11         "https://api.synthflow.ai/v2/calls",
12         headers={"Authorization": f"Bearer {API_KEY}"},
13         json={
14             "agent_id": agent_id,
15             "phone_number": test_phone,
16             "test_mode": True,
17             "initial_input": test["input"]
18         }
19     ).json()
20     
21     # Verify outcome
22     result = wait_for_call_completion(call["id"])
23     assert test["expected_action"] in result["actions"]

CI/CD Integration

1 # GitHub Actions workflow
2 name: Deploy Agent Updates
3 on:
4   push:
5     branches: [main]
6 
7 jobs:
8   deploy:
9     runs-on: ubuntu-latest
10     steps:
11       - uses: actions/checkout@v2
12       
13       - name: Update Agent Configuration
14         run: |
15           curl -X PATCH \
16             https://api.synthflow.ai/v2/agents/${{ secrets.AGENT_ID }} \
17             -H "Authorization: Bearer ${{ secrets.SYNTHFLOW_API_KEY }}" \
18             -H "Content-Type: application/json" \
19             -d @agent-config.json
20       
21       - name: Run Tests
22         run: python test_agent.py

Multi-Tenant SaaS Integration

1 // Your SaaS platform creates isolated agents per customer
2 async function provisionCustomerAgent(customer) {
3   // Create dedicated agent
4   const agent = await fetch('https://api.synthflow.ai/v2/agents', {
5     method: 'POST',
6     headers: {
7       'Authorization': `Bearer ${API_KEY}`,
8       'Content-Type': 'application/json'
9     },
10     body: JSON.stringify({
11       name: `${customer.companyName} Support Agent`,
12       prompt: generateCustomPrompt(customer),
13       voice: customer.preferences.voice,
14       model: customer.tier === 'enterprise' ? 'gpt-5-1' : 'gpt-4o'
15     })
16   }).then(r => r.json());
17   
18   // Store agent ID in your database
19   await db.customers.update(customer.id, {
20     synthflow_agent_id: agent.id
21   });
22   
23   return agent;
24 }

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 - Complete API documentation
Authentication - API key management
Agents API - Agent management endpoints
Calls API - Call initiation and management
Contacts API - Contact management
Custom Variables - Variable injection and extraction

Webhooks:

About Webhooks - Webhook overview
Inbound Webhook - Pre-call routing and data injection
Inbound Webhook API - API specification
Post-Call Webhook - Post-call automation
Webhooks - Complete webhook guide
Webhooks Security - HMAC validation

Advanced Features:

Dynamic Prompt Injection - Runtime prompt customization
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 (Co-Pilot): 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 (Co-Pilot)	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:

No-Code Resources:

Pro-Code Resources:

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.