GitHub API Error Classification & Team Routing Workflow Setup Guide

What This Agent Does

This intelligent workflow automatically captures GitHub issues related to API errors, analyzes them using AI, and routes them to the appropriate team with comprehensive documentation across multiple platforms. When a GitHub issue is created, the system classifies the error type, formats notification data, and simultaneously logs the issue in Airtable, creates a Notion database entry, and sends targeted Slack notifications to the responsible team.

Key benefits include:

• Eliminate manual triage: AI automatically classifies API errors, saving your team 15-20 minutes per issue
• Centralized tracking: Issues are logged in Airtable and Notion simultaneously for complete visibility
• Instant team alerts: Relevant teams receive immediate Slack notifications with classified error details
• Reduced response time: Pre-classified and routed issues reach the right team instantly, reducing time-to-resolution
• Consistent documentation: Every issue follows the same structured format across all platforms

Target use cases:

• SaaS platforms managing multiple API endpoints
• Development teams handling high-volume GitHub issues
• Organizations with distributed teams (DevOps, Backend, Support, API specialists)
• Companies requiring audit trails and issue documentation

Who Is It For

This workflow is ideal for technical teams of 5+ people managing APIs across multiple services. It's particularly valuable if you:

• Receive frequent GitHub issues related to API errors
• Have multiple specialized teams (DevOps, Backend, Support, API Team) that need different information
• Want to reduce manual issue categorization and routing
• Need centralized documentation across Airtable, Notion, and Slack
• Require quick response times to production issues

Required Integrations

GitHub

Why it's needed: GitHub serves as your issue trigger point. When new issues are created, they automatically initiate the workflow, capturing issue titles, descriptions, and metadata.

Setup steps:

1. Navigate to your GitHub repository settings
2. Go to Settings → Webhooks and click Add webhook
3. Set the Payload URL to your TaskAGI webhook endpoint (provided in the GitHub integration setup)
4. Select Issues as the event trigger
5. Ensure Active is checked
6. Click Add webhook

How to obtain credentials:

1. Go to GitHub Settings → Developer settings → Personal access tokens
2. Click Generate new token (classic)
3. Select scopes: repo, read:org, and admin:repo_hook
4. Copy the generated token immediately (it won't be shown again)

Configuration in TaskAGI:

• Paste your personal access token in the GitHub integration settings
• Verify connection by testing the webhook
• Confirm your repository is selected in the workflow trigger node

OpenAI

Why it's needed: OpenAI's GPT-4o model analyzes the GitHub issue content and classifies the API error type (DevOps, Backend, Support, or API Team issue), enabling intelligent routing.

Setup steps:

1. Visit platform.openai.com
2. Click your profile icon → API keys
3. Click Create new secret key
4. Name it "TaskAGI GitHub Classifier"
5. Copy the key immediately

How to obtain credentials:

• Ensure your OpenAI account has billing enabled
• Verify you have access to GPT-4o model (available in most plans)
• Keep your API key secure; never commit it to version control

Configuration in TaskAGI:

• Enter your OpenAI API key in the integration settings
• Set the model to gpt-4o in the "AI: Classify API Error" node
• The prompt is pre-configured to analyze GitHub issue titles and descriptions
• Set temperature to 0.3 for consistent, deterministic classifications

Airtable

Why it's needed: Airtable provides a structured database for tracking all classified issues with sortable fields, making it easy to query and report on API errors over time.

Setup steps:

1. Log in to airtable.com
2. Create a new base named "API Error Tracking"
3. Create four tables: DevOps Issues, Backend Issues, Support Issues, API Team Issues
4. In each table, add fields: Issue Title, Issue Description, Classification, GitHub URL, Created Date, Assigned Team
5. Go to Account → API and click Generate token
6. Select scopes: data.records:read, data.records:write, schema.bases:read

How to obtain credentials:

• Your Airtable API token is displayed once; copy it immediately
• Note your Base ID (visible in the URL: airtable.com/appXXXXXXXXXXXXXX)
• Note each Table ID (visible when you open a table)

Configuration in TaskAGI:

• Enter your API token in the Airtable integration
• For each "Airtable: [Team] Record" node, configure:
  • Base ID: Your API Error Tracking base
  • Table ID: Corresponding team table
  • Field mappings: Map workflow data to Airtable fields

Notion

Why it's needed: Notion provides a rich, collaborative workspace where teams can view, comment on, and manage issues with full formatting and linked databases.

Setup steps:

1. Log in to notion.so
2. Create a new page called "API Error Tracking"
3. Create a database with the following properties: Title, Description, Classification, GitHub URL, Team, Status, Created Date
4. Go to Settings & members → Integrations → Develop your own integrations
5. Create a new integration named "TaskAGI"
6. Copy the Internal Integration Token

How to obtain credentials:

• The integration token is shown once; save it securely
• Get your database ID from the Notion URL: notion.so/workspace/DATABASEID?v=...

Configuration in TaskAGI:

• Enter your Notion integration token
• For each "Notion: [Team] Entry" node, configure:
  • Database ID: Your API Error Tracking database
  • Property mappings: Map workflow data to Notion properties
  • Set the Team property based on the routing decision

Slack

Why it's needed: Slack delivers real-time notifications to team channels, ensuring immediate awareness of new API errors requiring attention.

Setup steps:

1. Go to api.slack.com/apps
2. Click Create New App → From scratch
3. Name it "TaskAGI Notifications"
4. Select your workspace
5. Go to OAuth & Permissions
6. Under Scopes, add chat:write
7. Click Install to Workspace
8. Copy the Bot User OAuth Token (starts with xoxb-)

How to obtain credentials:

• The OAuth token is displayed after installation
• Create four Slack channels: #devops-alerts, #backend-alerts, #support-alerts, #api-team-alerts
• Get each channel ID by right-clicking the channel → View channel details

Configuration in TaskAGI:

• Enter your Bot User OAuth Token
• For each "Slack: Notify [Team]" node, configure:
  • Channel: Corresponding team alert channel
  • Message format: Include issue title, classification, and GitHub URL
  • Enable thread replies for organized discussions

Configuration Steps

Node-by-Node Configuration

Nodes 1-3: Agent Name Options, Category & Industry, Workflow Overview These documentation nodes require no configuration. They serve as reference information for your workflow. Update the text to match your organization's naming conventions if desired.

Node 4: GitHub Issue Trigger

• Configuration: Select your GitHub repository
• Event type: Issues
• Trigger on: opened (new issues only)
• This node captures: issue title, description, author, creation date, and GitHub URL

Node 5: Prepare Issue Data

• Purpose: Extract and structure GitHub issue data for downstream processing
• Configuration:
  • Map github.issue.title → issueTitle
  • Map github.issue.body → issueDescription
  • Map github.issue.html_url → githubUrl
  • Map github.issue.created_at → createdDate
• Example output:

{
  "issueTitle": "API returns 500 on concurrent requests",
  "issueDescription": "When multiple requests hit endpoint...",
  "githubUrl": "https://github.com/org/repo/issues/123"
}

Node 6: AI: Classify API Error

• Model: gpt-4o
• Temperature: 0.3 (for consistency)
• Prompt: The system analyzes the issue title and description, returning one of four classifications: DevOps, Backend, Support, or API Team
• Output mapping: Store classification result as errorClassification
• Expected output: One of the four team categories

Node 7: Format Notification Data

• Purpose: Create a standardized message structure for all downstream notifications
• Configuration:
  • Combine issue title, classification, and GitHub URL
  • Add timestamp and issue author
  • Create a formatted summary for Slack and database entries
• Example output:

🚨 API Error Classified: Backend
Title: API returns 500 on concurrent requests
Team: Backend Team
GitHub: [Link]
Created: 2024-01-15 14:32 UTC

Node 8: Route by Assigned Team (Switch Node)

• Purpose: Direct the issue to the appropriate team's processing path
• Configuration: Create four cases based on errorClassification:
  • Case 0: DevOps → Routes to nodes 9, 10, 11
  • Case 1: Backend → Routes to nodes 12, 13, 14
  • Case 2: Support → Routes to nodes 15, 16, 17
  • Case 3: API Team → Routes to nodes 18, 19, 20
• Default case: Route to Support team if classification is unclear

Nodes 9, 12, 15, 18: Airtable Record Creation

• Configuration for each:
  • Base ID: Your API Error Tracking base
  • Table ID: Corresponding team table (DevOps Issues, Backend Issues, etc.)
  • Field mappings:
    • Issue Title ← issueTitle
    • Issue Description ← issueDescription
    • Classification ← errorClassification
    • GitHub URL ← githubUrl
    • Created Date ← createdDate
    • Assigned Team ← Team name (hardcoded per branch)

Nodes 10, 13, 16, 19: Notion Database Entry Creation

• Configuration for each:
  • Database ID: Your API Error Tracking database
  • Property mappings (same as Airtable)
  • Set Status property to "New"
  • Set Team property to corresponding team name
• Enable: Notion database relations if you want to link back to GitHub

Nodes 11, 14, 17, 20: Slack Notifications

• Configuration for each:
  • Channel: Corresponding team alert channel
  • Message format:

🚨 New API Error Detected
Title: [issueTitle]
Classification: [errorClassification]
GitHub: [githubUrl]
Assigned to: [Team Name]

• Enable rich formatting with buttons linking to GitHub and Airtable
• Set notification priority to "High"

Testing Your Agent

Step 1: Execute a Test Run

1. In TaskAGI, click Test Workflow
2. Create a test GitHub issue in your repository with title: "Test: API returns 500 error on concurrent requests"
3. Add description: "When multiple requests hit the /api/users endpoint simultaneously, the API returns a 500 error. This appears to be a backend concurrency issue."
4. Watch the workflow execute in real-time

Step 2: Verify Each Processing Stage

• After Node 5: Confirm issue data is extracted correctly in the debug panel
• After Node 6: Verify AI classification is accurate (should classify as "Backend")
• After Node 7: Check formatted notification data is complete and readable
• After Node 8: Confirm routing decision matches the classification

Step 3: Validate Output Across Platforms

• Airtable: Check that a new record appears in the Backend Issues table with all fields populated
• Notion: Verify a new database entry exists with correct properties and formatting
• Slack: Confirm the notification appears in the #backend-alerts channel with clickable links

Step 4: Success Indicators

✅ Workflow completes without errors ✅ Airtable record created with all fields ✅ Notion entry created and properly formatted ✅ Slack message delivered to correct channel ✅ All links (GitHub, Airtable, Notion) are functional ✅ Classification matches issue content

Troubleshooting Tips

• Classification incorrect? Review the OpenAI prompt and adjust keywords for your team's error types
• Slack message not sending? Verify bot token has chat:write scope and channel IDs are correct
• Airtable/Notion not updating? Check API credentials and field mappings match your database structure
• Workflow timing out? Increase timeout settings in each integration node to 30 seconds

Your workflow is now ready to automatically classify and route API errors to the right teams!