Ticket Sync

Polygent can synchronize tickets with external systems — GitHub Issues and Azure DevOps/TFS Work Items — so your team manages AI sessions from the project tracker they already use. This guide covers external sync; for the full ticket pipeline see the Tickets guide.

Supported integrations

Integration	Capabilities
GitHub	OAuth login, Issue sync, Issue creation, PR creation and live status tracking
Azure DevOps / TFS	Work item sync (Bugs), area-path/tag filters, status mapping, PR/MR tracking

Both use Personal Access Tokens (PAT) for authentication. GitHub uses workspace-level PATs; Azure DevOps additionally supports per-user PATs (encrypted, max 500 chars) managed via your Profile.

Setting up GitHub sync

1. Open the workspace Settings
2. Set Ticket Source to GitHub
3. Enable Tickets Sync Toggle
4. Configure the workspace Git PAT with scopes that allow issue read/write
5. Optionally set GitHub Label Filters — Polygent will sync only issues with matching labels

What syncs

• Inbound: GitHub issues → Polygent tickets
• Outbound: Status updates back to GitHub when configured
• Create GitHub Issue action available from the Polygent ticket UI

Setting up TFS / Azure DevOps sync

1. Open the workspace Settings
2. Set Ticket Source to TFS
3. Enable Tickets Sync Toggle
4. Configure:

Field	Description
TFS URL	Org or collection URL
TFS PAT	Workspace token (or use per-user PAT via Profile)
TFS Project	Target project
TFS Repository	Target repo
Area Path Filters	Sync only items under matching area paths
Tag Filters	Sync only items with matching tags
Status Mapping	Map TFS states ↔ Polygent ticket stages
Default Fields	Defaults applied when creating TFS bugs

What syncs

• Inbound: TFS work items → Polygent tickets
• Outbound: Create TFS Bug Work Item action available from the Polygent ticket UI
• Status flows both ways via the configured status mapping

Per-user PAT

Store your personal Azure DevOps PAT under your Profile → TFS Token Management. Per-user PATs are encrypted and scoped per-workspace — useful when each team member should perform Git/PR operations under their own identity.

Auto-Start Rules

Set tag-based Auto-Start Rules to automatically apply a Start Ticket Template when an incoming external ticket has a matching tag. Use this to:

• Auto-assign a workflow when a ticket is tagged auto-fix
• Set high priority when tagged urgent
• Pick a specific provider/model when tagged claude-only

When a synced ticket matches a rule, the corresponding template's preset (provider, model, workflow, session toggles) is applied at queue time.

Working with synced tickets

Synced tickets appear alongside manual tickets in the Tickets view:

• View ticket title, description, source (GitHub / TFS)
• Start an AI session directly from a ticket
• Track which sessions are linked to which ticket
• Sync status updates back to the external system

External tickets follow the same pipeline as manual tickets — see the Tickets guide for stages, approval flow, attachments, comments, and queue management.

Auto-cancel on external close

If you close a synced GitHub issue or move a TFS work item to Closed / Done / Removed directly in the external tracker, Polygent will auto-cancel the linked Polygent ticket on the next sync cycle (provided it isn't already in a terminal stage). The cancel goes through the standard ticket pipeline:

• The active session, if any, is canceled
• The slot is released so other queued tickets can advance
• The cancel reason is recorded in the ticket's stage history for the audit trail
• Dependent tickets blocked by the canceled ticket are unblocked

This avoids wasting AI agent budget on work that no longer needs to be done. Tickets already in Completed / Failed / Canceled are never re-touched.

PR creation and tracking

Once a ticket reaches the Pull Request stage:

Source	What happens
GitHub	Polygent creates a PR via the GitHub API; PR status is polled
Azure DevOps	Polygent creates a Pull Request / Merge Request via the Azure DevOps API

PR status is tracked through the ticket lifecycle (Open, Merged, Closed, Conflicts, Failed to Create). On merge, the ticket auto-completes.

Examples

Auto-fix labeled GitHub issues Tag GitHub issues with auto-fix. Create a matching Auto-Start Rule pointing at a template that uses your bug-fix workflow in Auto mode. Now any issue your team labels auto-fix syncs in, queues itself, and an agent starts implementing — without anyone opening Polygent.

Triage from your existing tracker Your team lives in Azure DevOps. Point the workspace at the project, set area-path and tag filters so only the relevant Bugs sync, and map TFS states to Polygent stages. Engineers keep working from Azure Boards; the AI pipeline runs against the same work items and status flows back automatically.

Stop wasting spend on cancelled work A synced GitHub issue is closed as "won't fix" directly on GitHub. On the next sync cycle Polygent auto-cancels the linked ticket, stops any running session, releases the slot, and unblocks dependent tickets — no AI budget burned on abandoned work.

Troubleshooting

• Sync isn't firing — Check Tickets Sync Toggle is on
• Issues are missing — Verify your label/area-path/tag filters aren't excluding them
• PR creation fails — Check the workspace PAT has repo (GitHub) or Code (read & write) (Azure DevOps) scope
• Status not flowing back — Confirm the Status Mapping covers the stages you care about

What's not synced

Polygent does not sync:

• Comments on the external ticket (Polygent comments live in Polygent)
• Subtasks/parent links
• Custom fields beyond what's covered by Default Fields and Status Mapping

Attachments sync one way to Azure DevOps / TFS only: files attached to a ticket are uploaded to the linked work item, and removing them locally removes them from the work item on the next sync. GitHub has no attachment API, so attachments stay local for GitHub-sourced tickets.

If you need full bidirectional sync of every field, use a dedicated sync platform — Polygent's sync is purpose-built around the AI ticket pipeline, not full project-tracker mirroring.