| 1 | --- |
| 2 | title: Ask g1t |
| 3 | description: Ask g1t about your work from the top bar of any page. It answers with your workspace's own AI provider and key, reads g1t as you with read-only access, and shows each step it takes and the pages it drew on. |
| 4 | --- |
| 5 | |
| 6 | **Ask**, in the top bar, opens a conversation with g1t beside the page |
| 7 | you are on. Ask about the work item you are reading, the pull request you are |
| 8 | reviewing, or anything else about your work, and the answer streams in as |
| 9 | it is written. |
| 10 | |
| 11 | Ask answers with **your workspace's own AI provider**, on your workspace's |
| 12 | own key: one of [your AI providers](/guides/ai/), |
| 13 | and **Auto** or the model an owner chose for it. g1t hosts no model for Ask and bills |
| 14 | nothing for it; what an answer costs is on your provider's bill. Your key |
| 15 | stays sealed in g1t: it is used to call the provider and is never sent to |
| 16 | your browser. |
| 17 | |
| 18 | ## Set it up |
| 19 | |
| 20 | An owner of the workspace sets it up once: |
| 21 | |
| 22 | 1. Open **AI**, in the workspace's settings, at |
| 23 | `g1t.sh/<workspace>/-/ai`. |
| 24 | 2. Add a provider if there is none yet: a frontier lab such as |
| 25 | Anthropic, OpenAI or Gemini, a model platform, or a model you host |
| 26 | yourself behind an Anthropic- or OpenAI-compatible endpoint. |
| 27 | 3. Under **Ask g1t**, choose the provider and its model, then **Use for |
| 28 | Ask**. The model starts at **Auto** (see [Auto](#auto)); choose one of |
| 29 | the models the provider offers to use that one for every answer. For |
| 30 | Azure OpenAI, give the deployment's name; for an endpoint that does not |
| 31 | list its models, the model's name. |
| 32 | |
| 33 | Every member can then ask. Until a provider is chosen, Ask says so: owners |
| 34 | get a link to set it up, and members are told to ask an owner. A message |
| 35 | to @g1t in Chat before then gets a short reply from g1t saying the same. **Turn Ask |
| 36 | off** on the same page stops it answering, and removing the provider it |
| 37 | uses does too. |
| 38 | |
| 39 | Every AI provider g1t connects works with Ask: Anthropic and |
| 40 | Anthropic-compatible endpoints through Anthropic's Messages API, and the |
| 41 | rest through OpenAI's Chat Completions API. |
| 42 | |
| 43 | ### Auto |
| 44 | |
| 45 | **Auto**, the default, picks one of the provider's models for each |
| 46 | question, by a fixed rule and with no extra call to the provider: |
| 47 | |
| 48 | | The question | Auto answers with | |
| 49 | | --- | --- | |
| 50 | | A lookup: who has a work item, a link, how many pull requests are open | The provider's newest fast model: Haiku, a `mini` or `flash` model, an `instant` one | |
| 51 | | One that needs several reads or reasoning: why or how something happened, what shipped, a day or a week summed up, a failure to diagnose, work to plan; a long question, several at once, or a long conversation | Its newest standard model: Sonnet, GPT, Gemini Pro, a `versatile` or `large` one | |
| 52 | |
| 53 | Auto tells models apart by the words in their names, from the list the |
| 54 | provider gave when it was last tested, so it works the same for every |
| 55 | provider. The largest and most expensive models, such as Opus or OpenAI's |
| 56 | `pro` models, are used only when the provider offers nothing else: every |
| 57 | answer is on your workspace's key. When a tier is missing, Auto uses the |
| 58 | nearest one. A provider that lists no models (an endpoint, an Azure |
| 59 | deployment) answers with its own model. If Auto has nothing to choose |
| 60 | from, Ask says so: test the provider to list its models again, or choose |
| 61 | one. |
| 62 | |
| 63 | Each answer names the model that wrote it, such as **Anthropic · Auto · |
| 64 | claude-sonnet-5-5**. Workspaces that chose Ask's model before Auto existed |
| 65 | and kept the one the picker started at moved to Auto; a model an owner |
| 66 | picked stays picked. |
| 67 | |
| 68 | ## What it can read |
| 69 | |
| 70 | Ask reads g1t to answer: whatever you can read, and nothing more. It uses |
| 71 | the same tools the [g1t MCP server](/reference/mcp/) gives any agent, run |
| 72 | as you: repositories and their files and commits, work items, pull requests |
| 73 | and their changes, workflow runs and their logs, deployments, releases, |
| 74 | production telemetry, and what happened across your workspace. Every read |
| 75 | goes through the same permission checks as your own, so it never sees a |
| 76 | repository, work item or log you could not open yourself. |
| 77 | |
| 78 | Each question asked from the panel is sent with a short note saying that |
| 79 | this is Ask in your workspace and which page you are on (a question |
| 80 | written in Chat says you are in Chat): the repository, and the work item or |
| 81 | pull request number, when there is one. On a work item or a pull request, |
| 82 | g1t also |
| 83 | reads its title, state and description, as you can see them, and sends |
| 84 | those along, so you can ask "what is left to do here?" without pasting |
| 85 | anything. |
| 86 | |
| 87 | It only reads. For each answer g1t makes a credential that is yours, holds |
| 88 | read permissions only, reaches only this workspace, and ends with the |
| 89 | answer, a few minutes at most. Nobody sees it: not the model, not your |
| 90 | browser. Anything that would change g1t is refused, whatever your role. |
| 91 | |
| 92 | Each question is also sent with which page you are on and today's date. On |
| 93 | a work item or a pull request, g1t sends its title, state and description, so |
| 94 | you can ask "what is left to do here?" without pasting anything. Some |
| 95 | questions it answers well: |
| 96 | |
| 97 | - What shipped today across all our projects? |
| 98 | - Why did the last Deploy fail? |
| 99 | - Summarize this pull request. |
| 100 | - How do I run this project's tests? |
| 101 | - What changed in this file recently, and why? |
| 102 | |
| 103 | For a question about the whole workspace, Ask reads the workspace's |
| 104 | activity first: merged pull requests, releases, deployments, workflow runs |
| 105 | and pushes across every repository you can read, in one read |
| 106 | (`activity` on the MCP server's `workspace` tool, or |
| 107 | [`GET /workspaces/{workspace}/activity`](/reference/api/workspaces/get-workspace-activity/)). |
| 108 | |
| 109 | ### What Ask means by shipped |
| 110 | |
| 111 | A change ships when it reaches a repository's default branch, pushed or |
| 112 | merged from a pull request, and then production. Production is a |
| 113 | successful deployment: |
| 114 | |
| 115 | - a project's production deployment on g1t.page, or |
| 116 | - for a repository that deploys itself, a successful run of its deploy |
| 117 | workflow on the default branch: a workflow whose name or file says |
| 118 | deploy, such as `.g1t/workflows/deploy.yml`, and not one for previews. |
| 119 | |
| 120 | Releases and tags are one more signal, not what shipping means. So "What |
| 121 | shipped today?" is answered with the commits that reached default branches |
| 122 | since the start of your day (in your profile's time zone), grouped by what |
| 123 | changed, and for each: **live** (with the deploy that carried it), **still |
| 124 | deploying**, **failed to deploy** (with the run, linked), or **not |
| 125 | deployed**. A deploy carries the commit it ran for and every commit before |
| 126 | it on the branch. |
| 127 | |
| 128 | People are named by their g1t username. A commit's author is matched to |
| 129 | the account their address belongs to (a confirmed address or the account's |
| 130 | noreply address, as commits on g1t.sh show them); a commit by an address |
| 131 | no account has is named as git recorded it, without an @. |
| 132 | |
| 133 | Answers link to what they name on g1t, and every number, title and link |
| 134 | comes from what Ask read; when something does not exist, it says so. |
| 135 | Answers come from a model and can still be wrong: follow the links to |
| 136 | check. |
| 137 | |
| 138 | ### Steps and sources |
| 139 | |
| 140 | While Ask works, the panel shows each step as it runs, such as **Read |
| 141 | activity in acme since 2026-10-12** or **Read pull request #7 in |
| 142 | acme/web**, with what it found and a link to the page it read. A step that |
| 143 | was refused, or that failed, says why. Once the answer is written the steps |
| 144 | fold into one line you can open again. Under the answer, **Sources** lists |
| 145 | the pages on g1t it links to, and the ones it read directly. |
| 146 | |
| 147 | ### Asking for work |
| 148 | |
| 149 | Ask does not do the work itself: it does not write code or change |
| 150 | anything. g1t coordinates the work, and a session in your own harness does |
| 151 | it. When you ask for work to be done, such as planning a change, fixing a |
| 152 | bug or implementing a work item, Ask reads the work item the work belongs |
| 153 | to, checks whether a session already holds it, and proposes a session: a |
| 154 | card under the answer that names the work item (or a new one it would |
| 155 | open) and |
| 156 | what the session should do (plan, implement or review). |
| 157 | |
| 158 | Nothing starts until you choose on the card: |
| 159 | |
| 160 | - **Start session** runs it on your workspace's Anthropic account as a |
| 161 | [Claude Managed Agents session](/guides/sessions/), with g1t's tools and |
| 162 | skills beside your own. It shows when an owner has connected Anthropic. |
| 163 | - **Copy Claude Code command** copies a `claude` command that runs it on |
| 164 | your computer with the [g1t plugin](/guides/claude-code-plugin/), with |
| 165 | your own skills, settings and subagents. |
| 166 | |
| 167 | Either way the session is tied to the work item: it shows on the work |
| 168 | item, on the workspace's [Sessions](/guides/sessions/#the-sessions-page) |
| 169 | and on its own session page, with |
| 170 | its subagents, and Ask can tell you where it stands. If a session already |
| 171 | holds the work item, Ask |
| 172 | links it rather than proposing another. |
| 173 | |
| 174 | ### Building something new |
| 175 | |
| 176 | Ask for something that has no repository yet, such as "build a status page |
| 177 | for our API", and the card proposes a new one in your workspace: **Build |
| 178 | "Status page" in acme/status-page**. Under its title it says what starting |
| 179 | it does, for example "Creates the private repository, turns on its |
| 180 | deployments, then runs in your own harness and pushes the first version, |
| 181 | which goes live on g1t.page." The repository is public only if you ask for |
| 182 | that, and deployments are left off if you ask for that too. |
| 183 | |
| 184 | Choosing **Start session** or **Copy Claude Code command**: |
| 185 | |
| 186 | 1. Creates the repository as you, with the work item's title as its project's |
| 187 | description. |
| 188 | 2. Turns on its [deployments](/guides/deployments/). This needs the |
| 189 | workspace on the g1t plan and the Admin role on the repository, which |
| 190 | you have as its creator. If it can't, the card says **Not deployed:** |
| 191 | and why, and the session still builds the app. |
| 192 | 3. Opens the work item, with the new repository as its origin, and starts |
| 193 | the session. |
| 194 | |
| 195 | The card then shows **Created** with a link to the repository, and **Live |
| 196 | once the first version is pushed at** its production address on |
| 197 | g1t.page. The session pushes its first working version straight to the |
| 198 | default branch, since an empty repository has nothing to open a pull |
| 199 | request against, closes the work item, and watches `g1t deploy list` until |
| 200 | production is live, ending its report with the address. Every change after |
| 201 | that goes through pull requests as usual. Choosing the card again, or Copy |
| 202 | after Start, uses the repository it already made. |
| 203 | |
| 204 | Ask itself still changes nothing: your click on the card does. For a |
| 205 | repository that already exists, deployments are turned on in its |
| 206 | **Settings → Deployments**. |
| 207 | |
| 208 | ## Ask from Home |
| 209 | |
| 210 | [Home](/guides/home/#ask-from-home) asks g1t for you in three places, all |
| 211 | in the same conversation as the panel: |
| 212 | |
| 213 | - **The box at the top**, under **What are we building today?**, and its |
| 214 | starters (**What needs me first?**, **What shipped today?**, **Who's |
| 215 | working on what?**). What you send there opens the Ask panel and is |
| 216 | sent as if you had typed it in the panel. |
| 217 | - **Explain**, on each row of **Landed**, asks what that one change did, |
| 218 | why, and whether it is live, in the panel. |
| 219 | - **Summarize**, on **What changed**, writes g1t's plain-English summary |
| 220 | of the span on Home itself, rather than in the panel. **Ask a |
| 221 | follow-up** under it opens the panel on the same conversation. |
| 222 | |
| 223 | When Ask is not set up yet, or g1t is still answering an earlier |
| 224 | question, the panel opens with the question in its box instead of |
| 225 | sending it; send it once it can be answered. |
| 226 | |
| 227 | ## One conversation, in Ask and in Chat |
| 228 | |
| 229 | Ask is your **direct message with @g1t** in [Chat](/guides/chat/#talk-with-g1t). |
| 230 | What you ask in the panel is posted there, and g1t's answer is written |
| 231 | there as it streams, so it shows in both places at once: start a question |
| 232 | on a work item's page, and read the answer later in Chat, on your phone, or |
| 233 | in the desktop app. **Open in Chat** at the top of the panel takes you to |
| 234 | it. Nobody else can read it, and it stays until you delete it or |
| 235 | [clear it](#clear-the-conversation). |
| 236 | |
| 237 | - **New conversation** leaves a mark in the direct message. From then on, |
| 238 | g1t reads only what comes after it, and the panel shows only that; what |
| 239 | came before stays in Chat to read. |
| 240 | - **Clear conversation…**, in the panel's **⋯** menu, deletes the whole |
| 241 | conversation for good. Typing `/clear` and pressing **Enter** does the |
| 242 | same. See [Clear the conversation](#clear-the-conversation). |
| 243 | - **Stop**, or **Esc** while an answer is coming, ends the answer; what had |
| 244 | come so far stays. Writing again while g1t is still answering does the |
| 245 | same: g1t stops and answers your newest words, reading both. |
| 246 | - **Answer again**, under g1t's latest answer, has it write that answer |
| 247 | anew. |
| 248 | - **Copy** copies an answer as Markdown. Each answer shows the provider |
| 249 | and model that wrote it, with **Auto** when Auto chose the model. |
| 250 | |
| 251 | Answers are Markdown: code is highlighted with its language and a Copy |
| 252 | button, tables scroll within the answer, and work items, pull requests and |
| 253 | commits (`#12`, `acme/web#12`, a link to one, a commit hash) show as chips that |
| 254 | open their title and state when you hover over them. Links to |
| 255 | [artifacts](/guides/artifacts/) show their card. Pictures show only from |
| 256 | g1t itself; any other picture is a link. |
| 257 | |
| 258 | In the panel, **Enter** sends, **Shift+Enter** starts a new line, and |
| 259 | **⌘K** (**Ctrl+K**) puts you back in the box. On an empty conversation, |
| 260 | the panel suggests a few questions for the page you are on. |
| 261 | |
| 262 | ## Clear the conversation |
| 263 | |
| 264 | **New conversation** only changes what g1t reads: everything said before |
| 265 | the mark is still kept, and still in Chat. To delete it, clear the |
| 266 | conversation: |
| 267 | |
| 268 | 1. Open **Ask** in the top bar, or your direct message with **g1t** in |
| 269 | Chat. |
| 270 | 2. Choose **⋯ → Clear conversation…**, or type `/clear` in the box and |
| 271 | press **Enter**. |
| 272 | 3. Choose **Clear conversation** to confirm. |
| 273 | |
| 274 | Everything in your direct message with g1t is deleted for good, in Ask |
| 275 | and in Chat, on every device. It can't be undone, and g1t remembers none |
| 276 | of it: the next question starts with nothing before it. |
| 277 | |
| 278 | | Deleted | Kept | |
| 279 | | --- | --- | |
| 280 | | Your questions, and the page each was asked from | The direct message itself, empty, so Ask and Chat open it as before | |
| 281 | | g1t's answers, with their steps, sources and proposed sessions | Chat's daily count of messages and bytes for the workspace, which has no text and no names in it and is kept for billing | |
| 282 | | Thread replies, reactions, "New conversation" marks, and deleted messages' empty places | Work items, pull requests and sessions you started from an answer: they are your workspace's, not the conversation's | |
| 283 | | Your read mark and unread count for it | What your AI provider was sent to answer: it went to the provider, under your workspace's agreement with them | |
| 284 | | The notifications its answers sent you, in g1t's notifications panel | Browser and phone notifications already shown on a device | |
| 285 | |
| 286 | An answer still being written when you clear is stopped and thrown away, |
| 287 | not saved: it never comes back to the conversation, and it does not |
| 288 | notify you. A question you send after clearing is answered as the start |
| 289 | of a new conversation. |
| 290 | |
| 291 | Clearing is only ever your own: nobody else can clear your conversation |
| 292 | with g1t, not even a workspace owner, and you can't clear anyone else's |
| 293 | or a channel. Clearing a conversation that is already empty does nothing. |
| 294 | |
| 295 | ## Limits |
| 296 | |
| 297 | - 20 questions a minute for each person; past that, g1t says to wait a |
| 298 | moment. |
| 299 | - g1t reads the conversation since the last **New conversation**, up to |
| 300 | its latest 40 messages and 64,000 characters, the newest first; a |
| 301 | message longer than 16,000 characters is cut to that. |
| 302 | - An answer is at most 4,096 tokens long, and says when it was cut off. |
| 303 | - An answer reads g1t in at most 10 rounds and 30 reads, over at most 2 |
| 304 | minutes; then it answers with what it has read and says what it could |
| 305 | not check. |
| 306 | - The model is given at most 16,000 characters of any one read and 120,000 |
| 307 | in all. A longer read is trimmed: long lists keep their first items (a |
| 308 | job's log keeps its end, where a failure says why), long texts are |
| 309 | shortened, and each says how much was left out. |
| 310 | - Its reads count against the [API's rate limit](/reference/rate-limits/) |
| 311 | like any other access token's. Each step is also a call to your AI |
| 312 | provider, on your provider's bill. |