| 1 | --- |
| 2 | title: Integrations |
| 3 | description: Connect the tools your team and you already use. Workspace integrations work for everyone in a workspace; personal ones work just for you, in every workspace. What is available today, what is coming, and how to ask for one. |
| 4 | --- |
| 5 | |
| 6 | g1t connects to the tools your work already lives in: where errors are |
| 7 | reported, where tickets are tracked, which models your agents think with, |
| 8 | where code came from. Every integration is listed in one directory, by |
| 9 | category, whether it works today or is still being built. The directory |
| 10 | is **Customize → Connectors** (see [Customize](/guides/customize/#connectors)), |
| 11 | beside the MCP servers a workspace connects there. |
| 12 | |
| 13 | ## Workspace and personal |
| 14 | |
| 15 | There are two places to connect things, and they are for different people: |
| 16 | |
| 17 | | | Workspace integrations | Your integrations | |
| 18 | | --- | --- | --- | |
| 19 | | Where | **Customize → Connectors**, at `g1t.sh/<workspace>/-/customize/connectors`, with each integration's setup page under `g1t.sh/<workspace>/-/integrations` | **Your settings → Integrations**, at [`g1t.sh/settings/integrations`](https://g1t.sh/settings/integrations) | |
| 20 | | Who it is for | Everyone in that workspace, people and agents | Just you, in every workspace you belong to | |
| 21 | | Who connects | Workspace owners. Members see what is connected. | You | |
| 22 | | Examples | Model providers, Sentry, Jira, Linear, GitHub mirroring, webhooks | Signing in with GitHub, agents you connect through MCP, and soon your calendar | |
| 23 | |
| 24 | Some tools have both sides. GitHub, for instance: a workspace owner |
| 25 | installs g1t's GitHub App to import and mirror the team's repositories, and |
| 26 | you link your own GitHub account to sign in with it. Each card says when |
| 27 | the other side exists. |
| 28 | |
| 29 | ## The directory |
| 30 | |
| 31 | Both pages are the same directory, the one **Customize → Connectors → |
| 32 | Discover** shows for a workspace: |
| 33 | |
| 34 | - **Categories** down the side (along the top on a phone): Code & CI, |
| 35 | Issues & projects, Chat & meetings, Calendar & email, Docs & knowledge, |
| 36 | Monitoring & incidents, Cloud & deploy, AI models, Data & analytics, |
| 37 | CRM & support, Design, Security & identity, and Files & storage. Each |
| 38 | shows how many integrations it has. A link can open on one, with |
| 39 | `?category=ai` and so on. |
| 40 | - **Search** finds an integration by name, by what it does ("in a meeting", |
| 41 | "opens issues"), or by a tag, across every category. |
| 42 | - **Connected** comes first: what is set up here, with a line about each |
| 43 | (the account, how many connections) and **Needs attention** when |
| 44 | something is wrong, such as a key that stopped working or a GitHub |
| 45 | installation that was suspended. Choose one to manage it. |
| 46 | - **Available** can be connected now. Choose one to open its setup page. |
| 47 | - **Soon** is being built. Each says what it will do, and **Ask for this** |
| 48 | tells g1t you want it (below). |
| 49 | - **Connect** on a tool that publishes a remote MCP server (Linear, Notion, |
| 50 | Sentry, Stripe, Figma, Supabase, Cloudflare and more) connects it as a |
| 51 | [connector](/guides/customize/#connectors): an owner signs in with the |
| 52 | browser or pastes a key, g1t lists its tools, and they are given to |
| 53 | agents with a level each. The integrations below have setup pages of |
| 54 | their own. |
| 55 | |
| 56 | The tags on a card say what an integration lets g1t do: **Agents can |
| 57 | read** (agents fetch what work refers to), **Opens issues**, **Writes |
| 58 | back** (the other system hears when work lands), **Mirrors repositories**, |
| 59 | **Runs models**, **Sets your status**, and so on. |
| 60 | |
| 61 | ## Available today |
| 62 | |
| 63 | | Category | Workspace | Personal | |
| 64 | | --- | --- | --- | |
| 65 | | Code & CI | [GitHub](/guides/github/) import and mirroring, [webhooks](/guides/webhooks/) | [Signing in with GitHub](/guides/github/#link-and-unlink-github) | |
| 66 | | Issues & projects | [Jira and Linear](#trackers) | | |
| 67 | | Monitoring & incidents | [Sentry, Datadog, and any system that sends a webhook](#alerts) | | |
| 68 | | AI models | [Model providers](/guides/models/): Anthropic, OpenAI, Google Gemini, xAI, Mistral, DeepSeek, Azure OpenAI, OpenRouter, Groq, Together AI, Fireworks AI, Cerebras, and any Anthropic- or OpenAI-compatible endpoint; the [AI Gateway](/guides/ai-gateway/) | [MCP clients](/guides/authentication/#signing-in-with-oauth): your own agent, connected to g1t as you | |
| 69 | |
| 70 | Model providers, alerts and trackers each have a setup page under the |
| 71 | directory: `-/integrations/models`, `-/integrations/alerts` and |
| 72 | `-/integrations/trackers`. GitHub, webhooks and the AI Gateway keep their |
| 73 | own pages; the directory links to them. |
| 74 | |
| 75 | Tools that publish a remote MCP server are connected from Customize rather |
| 76 | than from a setup page; see [connectors](/guides/customize/#connectors). |
| 77 | |
| 78 | Secrets are sealed when they are saved and never shown again, to anyone. |
| 79 | A setup page shows the last four characters of a key, so you can tell keys |
| 80 | apart. Agents never see a connection's secrets. |
| 81 | |
| 82 | ## Coming soon |
| 83 | |
| 84 | Every category has integrations on the way, among them Slack, Microsoft |
| 85 | Teams, Notion, Confluence, PagerDuty, Cloudflare, AWS, Figma, Okta and |
| 86 | Google Drive for workspaces. For you: **Google Calendar** and **Outlook |
| 87 | Calendar** will set your [status](/guides/chat/#presence-and-status) to *In a meeting* while |
| 88 | you are in one, and let agents find a time that suits everyone; **Zoom** |
| 89 | and **Google Meet** will set it to *On a call*. A status you set by hand |
| 90 | always wins over one an integration sets. |
| 91 | |
| 92 | The directory lists them all. Nothing on a **Soon** card does anything |
| 93 | yet. |
| 94 | |
| 95 | ## Ask for an integration |
| 96 | |
| 97 | On any **Soon** card, **Ask for this** opens an email to g1t with the |
| 98 | integration and your workspace (or "for my own account") filled in. Add |
| 99 | what you would use it for and send it. Searching for something that is |
| 100 | not listed offers the same, for whatever you searched for. Requests decide |
| 101 | what is built next. |
| 102 | |
| 103 | ## Alerts |
| 104 | |
| 105 | An alert source opens issues in one repository. Each problem it reports is |
| 106 | one issue: |
| 107 | |
| 108 | - **The first alert** opens an issue labelled `bug` (or the label you set) |
| 109 | and the provider's name, with what the provider said about the problem. |
| 110 | - **The same problem again** updates that issue instead of opening another. |
| 111 | The issue says so when the count passes 10, 100, 1,000 and so on. |
| 112 | - **The same problem after its issue was closed** reopens it, with a comment |
| 113 | linking the new occurrence. |
| 114 | - **A recovery** (Datadog) is noted on the issue. |
| 115 | |
| 116 | Turn on **Assign each new issue to g1t** and g1t starts on the |
| 117 | issue as soon as it opens: it makes the change, is reviewed, revises, and |
| 118 | lands through your repository's rules, often before anyone has looked. A |
| 119 | reopened issue gets an agent again. Agents need a way to reach a model: |
| 120 | [your own provider](/guides/models/), or g1t's hosted models where they are |
| 121 | open. Without one, the issue says why no agent started. |
| 122 | |
| 123 | Text in an alert can include what your users typed, such as an error |
| 124 | message built from a request. Issues opened from alerts say so, and agents |
| 125 | treat that text as a description of the problem, never as instructions. |
| 126 | |
| 127 | Each alert connection shows its last five deliveries: what arrived, and |
| 128 | whether g1t opened, updated, reopened, ignored or refused it. |
| 129 | |
| 130 | ### Sentry |
| 131 | |
| 132 | 1. On the **Integrations** page, choose **Sentry**. Give your organization's |
| 133 | slug and the repository issues go to, then **Connect**. |
| 134 | 2. In Sentry, open **Settings → Developer Settings → Custom Integrations** |
| 135 | and create an **internal integration**: |
| 136 | - **Webhook URL**: the address g1t shows on the connection, |
| 137 | `https://api.g1t.sh/hooks/<connection>`. |
| 138 | - Turn on **Alert Rule Action**, and under **Webhooks** tick **issue**. |
| 139 | - **Permissions**: Issue & Event, read and write. |
| 140 | 3. Save it. Paste its **client secret** into the connection on g1t, and its |
| 141 | **token** as the connection's auth token. |
| 142 | |
| 143 | Then: |
| 144 | |
| 145 | - New Sentry issues open g1t issues. So does any alert rule whose action |
| 146 | sends a notification to the integration. |
| 147 | - With the token, g1t adds the latest event's stack trace, in-app frames |
| 148 | first, so the agent starts at the failing line. |
| 149 | - When the fix merges, g1t resolves the Sentry issue and comments with the |
| 150 | pull request. If Sentry sees it again, the g1t issue reopens. |
| 151 | |
| 152 | Requests without a valid `Sentry-Hook-Signature` are refused. |
| 153 | |
| 154 | ### Datadog |
| 155 | |
| 156 | 1. On the **Integrations** page, choose **Datadog**, pick the repository, |
| 157 | and **Connect**. g1t shows a signing secret once; copy it. |
| 158 | 2. In Datadog, open **Integrations → Webhooks** and add a webhook named |
| 159 | `g1t`: |
| 160 | - **URL**: the connection's address. |
| 161 | - **Custom headers**: `{"Authorization": "Bearer <signing secret>"}` |
| 162 | - **Payload**: |
| 163 | |
| 164 | ```json |
| 165 | { |
| 166 | "id": "$ALERT_ID", |
| 167 | "title": "$EVENT_TITLE", |
| 168 | "body": "$EVENT_MSG", |
| 169 | "url": "$LINK", |
| 170 | "status": "$ALERT_TRANSITION", |
| 171 | "priority": "$PRIORITY" |
| 172 | } |
| 173 | ``` |
| 174 | |
| 175 | 3. Mention `@webhook-g1t` in the message of any monitor that should open |
| 176 | issues. |
| 177 | |
| 178 | A monitor that triggers opens an issue; `Recovered` is noted on it. |
| 179 | |
| 180 | ### Any other system |
| 181 | |
| 182 | The **Webhook** connection takes JSON from anything that can send it: |
| 183 | PagerDuty, Grafana, a deploy script. |
| 184 | |
| 185 | ```sh |
| 186 | body='{"id":"checkout-500","title":"Checkout returns 500 for empty carts","body":"POST /checkout fails."}' |
| 187 | curl -X POST https://api.g1t.sh/hooks/$CONNECTION \ |
| 188 | -H "Content-Type: application/json" \ |
| 189 | -H "X-G1t-Signature: sha256=$(printf '%s' "$body" | openssl dgst -sha256 -hmac "$SECRET" -hex | cut -d' ' -f2)" \ |
| 190 | -d "$body" |
| 191 | ``` |
| 192 | |
| 193 | Sign it either way: |
| 194 | |
| 195 | - `X-G1t-Signature: sha256=<hex HMAC-SHA256 of the body>`, with the signing |
| 196 | secret as the key, or |
| 197 | - `Authorization: Bearer <signing secret>`. |
| 198 | |
| 199 | g1t reads these fields, taking the first name present: |
| 200 | |
| 201 | | Field | Names | Notes | |
| 202 | | --- | --- | --- | |
| 203 | | Title | `title`, `event_title`, `summary`, `name` | Required. | |
| 204 | | Id | `id`, `alert_id`, `aggregate`, `incident_key`, `dedup_key` | Alerts with the same id are one issue. The title if missing. | |
| 205 | | Description | `body`, `message`, `event_msg`, `text`, `description` | Markdown. | |
| 206 | | Link | `url`, `link`, `html_url` | | |
| 207 | | State | `status`, `transition`, `alert_transition`, `state` | `recovered`, `resolved`, `ok` or `closed` means it stopped. | |
| 208 | | Priority | `priority`, `severity`, `level` | | |
| 209 | | Count | `count` | How many times it has happened. | |
| 210 | |
| 211 | g1t answers `202` once the request is verified and acts on it just after, |
| 212 | so a slow step never makes the sender retry. It answers `401` to a request |
| 213 | that is not signed, and `200` with the reason to one it ignores. |
| 214 | |
| 215 | ## Trackers |
| 216 | |
| 217 | Connect Jira or Linear and tickets become something agents and people can |
| 218 | reach from g1t. |
| 219 | |
| 220 | ### Agents read tickets the work mentions |
| 221 | |
| 222 | When g1t starts on an issue, or plans an outcome, g1t looks for |
| 223 | ticket keys and addresses in the text (`TECH-1234`, |
| 224 | `https://acme.atlassian.net/browse/TECH-1234`, |
| 225 | `https://linear.app/acme/issue/ENG-42/…`, a Sentry issue's address) and |
| 226 | fetches each from the system it lives in. The agent gets their titles, |
| 227 | statuses and descriptions as reference material, and its session notes |
| 228 | what it read. |
| 229 | |
| 230 | So a brief of "Accomplish TECH-1234" works: the planner reads the ticket. |
| 231 | |
| 232 | Agents, and your own agent through MCP, can also look a reference up with |
| 233 | the `search` tool's `ticket` action: |
| 234 | |
| 235 | ```sh |
| 236 | curl "https://api.g1t.sh/repos/acme/web/context?reference=TECH-1234" \ |
| 237 | -H "Authorization: Bearer $G1T_TOKEN" |
| 238 | ``` |
| 239 | |
| 240 | ### Import a ticket as an issue |
| 241 | |
| 242 | On a repository's **New issue** page, give a key or paste an address under |
| 243 | **Bring one in**. g1t opens an issue with the ticket's title and |
| 244 | description, linked to it. Tick **Put an agent on it** to start one at |
| 245 | once. Importing the same ticket again opens the issue already made. |
| 246 | |
| 247 | From the API or an agent: |
| 248 | |
| 249 | ```sh |
| 250 | curl -X POST https://api.g1t.sh/repos/acme/web/issues/import \ |
| 251 | -H "Authorization: Bearer $G1T_TOKEN" -H "Content-Type: application/json" \ |
| 252 | -d '{"reference": "TECH-1234", "assign": true}' |
| 253 | ``` |
| 254 | |
| 255 | An issue tied to something outside g1t shows it under **From outside g1t**, |
| 256 | with a link to the original. |
| 257 | |
| 258 | ### Tickets hear back |
| 259 | |
| 260 | Unless you turn it off, g1t comments on the ticket when a pull request |
| 261 | opens for its issue, and again when the issue closes as done, with a link |
| 262 | to what merged. For Sentry, closing as done resolves the Sentry issue. |
| 263 | |
| 264 | ### Jira |
| 265 | |
| 266 | | Setting | | |
| 267 | | --- | --- | |
| 268 | | Site | Your Jira's address, such as `https://acme.atlassian.net`. | |
| 269 | | Email | The Atlassian account the API token belongs to. | |
| 270 | | API token | From id.atlassian.com, **Security → API tokens**. g1t sees what that account can see. | |
| 271 | | Project keys | Optional. The projects this connection answers for, such as `TECH, OPS`. Empty answers for any key. | |
| 272 | |
| 273 | ### Linear |
| 274 | |
| 275 | | Setting | | |
| 276 | | --- | --- | |
| 277 | | API key | From Linear, **Settings → Security & access → Personal API keys**. | |
| 278 | | Team keys | Optional, such as `ENG`. Empty answers for any key. | |
| 279 | |
| 280 | A key that matches several connections is looked up in the ones that name |
| 281 | its project first. |
| 282 | |
| 283 | ## From the API |
| 284 | |
| 285 | Owners can manage integrations through the API and MCP, with a person's |
| 286 | token (a workspace token or an agent cannot): |
| 287 | |
| 288 | | MCP tool and action | Route | |
| 289 | | --- | --- | |
| 290 | | `workspace` `list_integrations` | `GET /workspaces/{workspace}/integrations` | |
| 291 | | `workspace` `connect_integration` | `POST /workspaces/{workspace}/integrations` | |
| 292 | | `workspace` `update_integration` | `PATCH /workspaces/{workspace}/integrations/{id}` | |
| 293 | | `workspace` `test_integration` | `POST /workspaces/{workspace}/integrations/{id}/test` | |
| 294 | | `workspace` `disconnect_integration` | `DELETE /workspaces/{workspace}/integrations/{id}` | |
| 295 | | `search` `ticket` | `GET /repos/{owner}/{name}/context?reference=` | |
| 296 | | `issue` `import` | `POST /repos/{owner}/{name}/issues/import` | |
| 297 | |
| 298 | ```sh |
| 299 | curl -X POST https://api.g1t.sh/workspaces/acme/integrations \ |
| 300 | -H "Authorization: Bearer $G1T_TOKEN" -H "Content-Type: application/json" \ |
| 301 | -d '{"provider": "jira", "config": {"site": "https://acme.atlassian.net", "email": "dev@acme.com", "keys": ["TECH"]}, "secret": "<api token>"}' |
| 302 | ``` |
| 303 | |
| 304 | Connectors (MCP servers) and their grants are the |
| 305 | [`customize`](/guides/customize/#api) resource's, not the integrations'. |
| 306 | |
| 307 | `provider` is one of the [model providers](/guides/models/#from-the-api), |
| 308 | or `sentry`, `datadog`, `webhook`, `jira` or `linear`. `config` takes `repo`, `assign`, `label`, |
| 309 | `write_back`, `organization`, `site`, `email`, `keys`, `base_url`, |
| 310 | `auth_header` and `model`; each provider uses the ones above. For `datadog` |
| 311 | and `webhook`, the response's `signing_secret` is the only time the secret |
| 312 | is shown. |