| 1 | # g1t plan |
| 2 | |
| 3 | g1t is where people and agents ship software together: a git platform built on Cloudflare Workers and Artifacts for |
| 4 | the "Build the Next-Gen Git Platform on Cloudflare" competition. |
| 5 | |
| 6 | - Submission closes **October 14, 2026, 11:59 PM PDT**: a 5–10 minute demo |
| 7 | video, this repository (MIT) and run instructions. |
| 8 | - Judging: 50% originality and quality of the prototype for agent-oriented |
| 9 | collaboration; 25% multi-agent concurrency, coordination, context |
| 10 | preservation, review and conflict handling; 25% ease of use. |
| 11 | |
| 12 | ## The point |
| 13 | |
| 14 | **g1t is where a team of agents ships code, with the people they work for.** |
| 15 | |
| 16 | Hosting git is table stakes, and g1t does it the familiar way: issues, |
| 17 | branches, pull requests, review, protected branches, people working by hand. |
| 18 | None of that is the selling point. The selling point is the layer above it, |
| 19 | which no forge has: **you hand g1t an outcome, and a fleet of agents converges |
| 20 | it onto `main`, coordinating with each other and with you, with every decision |
| 21 | on the record.** |
| 22 | |
| 23 | Three things only g1t does, and every feature should serve one of them: |
| 24 | |
| 25 | 1. **Outcomes, not pull requests.** The unit people work in is "make onboarding |
| 26 | work offline", not branch #4012. A brief becomes a plan of issues with |
| 27 | dependencies; agents take them as they unblock; people steer the outcome |
| 28 | and see it converge, rather than stopping at the pull request. |
| 29 | 2. **Agents that work as a team.** Agents know what the others are doing, file |
| 30 | what they find instead of widening their change, ask and answer each other |
| 31 | through the forge, and defer to people. Many agents on one codebase without |
| 32 | a human refereeing collisions. |
| 33 | 3. **`main` that only ever moves forward.** Every change lands through checks |
| 34 | in the combination it will live in (the merge queue), failures go back to the |
| 35 | agent that wrote them, and any line can answer "why is this here?" |
| 36 | |
| 37 | ## Product model |
| 38 | |
| 39 | g1t keeps the two things every engineer already knows, issues and pull |
| 40 | requests, and changes the assumption underneath them. A forge built for |
| 41 | people expects a few changes in flight, each watched by its author. g1t |
| 42 | expects dozens of agents working at once across a project, each on its own |
| 43 | issue, all of which have to land on `main`. A person assigns an issue to |
| 44 | g1t and chooses nothing else: not how many agents, and not which |
| 45 | model. An issue can still collect more than one pull request (a second |
| 46 | attempt, or someone's own agent alongside g1t's), and when it does the |
| 47 | issue records which one was taken. |
| 48 | |
| 49 | | Concept | What it is | |
| 50 | | --- | --- | |
| 51 | | **Issue** | What should change in a repo: a bug, a feature, a question. Opened by a person, an agent or an integration such as an error tracker. Carries labels, a description that may say what done means (a Definition of done: context, never a gate), comments, and every pull request made for it. What a merge needs is the default branch's required checks: workflow statuses, the same for people and agents. | |
| 52 | | **Pull request** | A proposed change in its own Artifacts fork, made by an agent or a person, usually for an issue. Any number can be open for one issue. Starts as a draft; marked ready; merged or closed. | |
| 53 | | **Session** | The agent's full context for a pull request: prompt, messages, tool calls, cost. Stored with the pull request and linked from every commit it produced. | |
| 54 | | **Compare view** | Every pull request for an issue side by side with diff, check results, conflicts against main and against each other, and a reviewer agent's summary. | |
| 55 | | **Merge** | A person or a policy picks a pull request. A per-repo merge queue lands it. The issue closes, recording which pull request resolved it; the others for that issue close as superseded, or are rebased by their agents when the issue is kept open. | |
| 56 | |
| 57 | Issues and pull requests share one sequence of numbers per repository, so |
| 58 | `#12` names exactly one of them. |
| 59 | |
| 60 | Features that fall out of the model: |
| 61 | |
| 62 | - **Why-blame.** Click a line and see the prompt and reasoning that produced |
| 63 | it, not only the commit. |
| 64 | - **Overlap radar.** Pull requests that touch the same files are flagged |
| 65 | while the agents are still working, and the agents are told. |
| 66 | - **Live lanes.** Watch every pull request progress in real time. |
| 67 | |
| 68 | ## Why issues and pull requests, not something new |
| 69 | |
| 70 | An earlier version of this plan merged the two into one new object, an |
| 71 | "issue" holding "pull requests". That was wrong, for three reasons. |
| 72 | |
| 73 | - **Issues come from everywhere.** People file them, agents file them, and |
| 74 | Sentry files them. Most are never worked on by whoever opened them. They |
| 75 | need their own life: labels, triage, discussion, closing as not planned. |
| 76 | - **"Which change did we take?" needs two objects.** When five agents each |
| 77 | propose a change, the answer has to be recorded somewhere other than the |
| 78 | five proposals. On g1t it is on the issue: `resolved by #14`. |
| 79 | - **Nobody should have to learn a word to use the product.** An engineer who |
| 80 | has used any forge can use g1t on the first day, and finds the agent |
| 81 | features where they would look for them. |
| 82 | |
| 83 | What g1t adds to the familiar pair: |
| 84 | |
| 85 | - **Several pull requests per issue is supported**, not an accident. It |
| 86 | is the exception, for a second attempt or a competing one, but when it |
| 87 | happens the issue's page lists them with their state, and merging one |
| 88 | closes the issue with that pull request recorded and the others marked |
| 89 | superseded. |
| 90 | - **A pull request can be part of the work.** Merging with "keep the issue |
| 91 | open" leaves the issue and its other pull requests alone. |
| 92 | - **Every pull request has a fork and a session.** See |
| 93 | [forks and branches](https://docs.g1t.sh/concepts/forks/). |
| 94 | - **Labels need no setup.** A repository starts with the default labels |
| 95 | (`bug`, `documentation`, `enhancement`, `question`, `dependencies`, |
| 96 | `security` and the rest), each with a color and a description, on issues |
| 97 | and pull requests alike; someone with Triage makes a new one as they use |
| 98 | it. **Milestones** gather issues and pull requests under a goal and a |
| 99 | due date. Pull requests can merge into any branch; the default branch's |
| 100 | protection holds only for those into it. |
| 101 | - **The developer path is unchanged.** Push a branch, open a pull request |
| 102 | from it, get review, merge. Agents get a fork per pull request instead. |
| 103 | - **Both paths meet at `main`.** The same landing rules apply to a person's |
| 104 | pull request and an agent's. |
| 105 | |
| 106 | ## Converging on main |
| 107 | |
| 108 | Twelve issues started together will finish at different times and touch |
| 109 | overlapping code. Getting them all into `main` without a person refereeing |
| 110 | is the hard part, and it is handled in four places. |
| 111 | |
| 112 | 1. **Before work starts: plan the overlap away.** A project is a graph of |
| 113 | issues. A planner agent can split a large goal into issues, predict |
| 114 | which files each will touch, and add a dependency where two would collide, |
| 115 | so one starts from the other's result instead of from `main`. |
| 116 | 2. **While agents work: overlap radar.** Each pull request's changed files and |
| 117 | symbols are tracked as it pushes. When two pull requests from different issues |
| 118 | enter the same area, both agents are told what the other is doing there. |
| 119 | 3. **When `main` moves: the author resolves.** Every open pull request is |
| 120 | trial-merged against the new `main`. A clean merge updates the pull request |
| 121 | silently. A conflict resumes that pull request's agent with its original |
| 122 | session and the incoming change, so the conflict is resolved by the agent |
| 123 | that wrote the code and still knows why. |
| 124 | 4. **At landing: a speculative queue.** Approved pull requests enter the |
| 125 | repo's queue. g1t builds the combined states (`main`+A, `main`+A+B, …) and runs |
| 126 | their checks in parallel. Pull requests land in order as their combined state |
| 127 | passes; one that fails is ejected back to its agent and the states behind |
| 128 | it are rebuilt. `main` only ever receives a state that passed. |
| 129 | |
| 130 | Landing can be fully automatic: a repo policy such as "checks pass and the |
| 131 | reviewer agent approves" merges without a person. |
| 132 | |
| 133 | ## Agents aware of each other |
| 134 | |
| 135 | Each repo keeps a live **work registry**: for every running pull request, its |
| 136 | issue, a running summary of what it has done, and the files and symbols it |
| 137 | has touched or plans to touch. Agents use it through MCP tools; g1t also |
| 138 | acts on it without being asked. |
| 139 | |
| 140 | - **Before starting.** When an issue is opened, or an agent is about to |
| 141 | begin a task, g1t searches open issues and running pull requests for the same |
| 142 | goal (by meaning, not wording) and for the same area of code. If a match |
| 143 | exists the agent is told who is on it and how far along, and chooses: join |
| 144 | as a deliberate racer, wait for the result, or drop the task. Duplicate |
| 145 | issues are offered for merging. |
| 146 | - **Finding out-of-scope work.** An agent that discovers something outside |
| 147 | its issue asks the registry who works there. If another pull request owns that |
| 148 | area, it **hands off**: a note, the relevant excerpt of its session, and |
| 149 | optionally commits the receiver can take. If nobody does, it opens a child |
| 150 | issue instead of widening its own change. |
| 151 | - **Asking.** An agent can put a question or a request to another pull request. |
| 152 | The receiver gets it at its next turn. |
| 153 | - **Waiting.** An agent that needs another pull request's result parks itself. |
| 154 | Its sandbox sleeps, spend stops, and it resumes from the new state when |
| 155 | that pull request merges. |
| 156 | - **Agents that do not cooperate.** For pushes from tools that never call |
| 157 | these tools, g1t compares the pushed change against running pull requests and |
| 158 | flags near-duplicates itself. |
| 159 | |
| 160 | Every handoff, question and wait has a state (offered, accepted, declined, |
| 161 | done), appears in the timeline, and is visible to people. A handoff declined |
| 162 | twice, or two agents passing work back and forth, goes to the "needs you" |
| 163 | inbox. |
| 164 | |
| 165 | ## Review at scale |
| 166 | |
| 167 | Cloudflare's brief asks "how do you review everything they produce?". With |
| 168 | hundreds of agents, a person cannot read every diff, so review is by |
| 169 | exception. |
| 170 | |
| 171 | - **Evidence, not diffs.** Every pull request carries a proof bundle: checks run |
| 172 | and their output, a preview URL, a plain-language summary, and the |
| 173 | behaviour that changed. |
| 174 | - **Two agent reviewers.** One reviews the change against the issue. A |
| 175 | second is adversarial: it tries to break the change and reports what it |
| 176 | found. |
| 177 | - **Risk tiers.** Each change is scored from what it touches, how large it |
| 178 | is, and how the reviewers ruled. Low risk merges on policy; high risk goes |
| 179 | to a person with the evidence already assembled. |
| 180 | - **Trust is earned.** An agent's record on a path (merged, reverted, caught |
| 181 | by review) raises or lowers the tier its changes land in. |
| 182 | - **Sampling.** A share of auto-merged changes is sent to a person anyway, |
| 183 | to keep the policy honest. |
| 184 | |
| 185 | ## Rethinking the git primitives |
| 186 | |
| 187 | - **No branches for agents.** A pull request is a fork; `main` is the only |
| 188 | long-lived line. There is nothing to name, clean up or go stale. |
| 189 | - **Projected main.** New pull requests start from `main` plus everything already |
| 190 | in the landing queue, so they are built on the state they will land on. |
| 191 | - **Structural merge.** The merge engine merges by syntax tree, not by line, |
| 192 | for supported languages. Two agents adding different functions to the same |
| 193 | file do not conflict. |
| 194 | - **Forkable sessions.** A session can be forked at any turn: the code as it |
| 195 | was at that moment plus the conversation up to it, continued with a |
| 196 | different instruction. Branching applies to the reasoning as well as the |
| 197 | code. |
| 198 | - **Provenance in history.** Every commit records its issue, session, |
| 199 | agent, model and cost, and is signed with a key issued to that pull request. The |
| 200 | history can be audited by machine. |
| 201 | |
| 202 | ## People in the loop |
| 203 | |
| 204 | ### Code that arrives from outside |
| 205 | |
| 206 | People will keep pushing with plain git, their editor, or another tool. Every |
| 207 | push goes through g1t's git front end, so none of it bypasses the model. |
| 208 | |
| 209 | - **A push to a branch becomes a pull request.** g1t adopts it with the pusher as |
| 210 | author. A reviewer agent writes the issue it appears to serve and offers |
| 211 | to attach it to an open issue it matches. From there it gets the same |
| 212 | checks, compare view and queue as agent work. |
| 213 | - **A push to `main` follows repo policy.** Protected: refused with a message |
| 214 | saying which ref to push to instead, so it enters the queue. Open: accepted |
| 215 | and treated as "`main` moved", which re-verifies the queue and triggers |
| 216 | resolve-on-move for every open pull request. |
| 217 | - **Context is an open format.** A commit trailer names the session that |
| 218 | produced it, so any tool can attach its transcript. Commits without one are |
| 219 | shown in why-blame as "pushed by a person, no session". |
| 220 | - **Approval rules.** Per repo and per path: merge automatically, require a |
| 221 | named person, or require a person when the change is large or the reviewer |
| 222 | agent is unsure. |
| 223 | |
| 224 | ### Joining work that is already running |
| 225 | |
| 226 | - **Every session has a live page** that works on a phone: the transcript as |
| 227 | it streams, the current diff, check results. |
| 228 | - **Steer.** Send a message, pause, or redirect. Hosted agents receive it |
| 229 | immediately; a person's own Claude Code receives it at its next turn |
| 230 | through the CLI hooks. |
| 231 | - **Answer.** When an agent is blocked on a question, it appears in a "needs |
| 232 | you" inbox and as a notification. The answer resumes the agent. |
| 233 | - **Take over and hand back.** Check out the pull request's fork, commit by hand, |
| 234 | push, and let the agent continue from there. |
| 235 | |
| 236 | ### Planning by writing |
| 237 | |
| 238 | - **Brief.** Write the outcome in prose on the site, or commit it as a |
| 239 | markdown file. A planner agent turns it into a project: issues, each with |
| 240 | what done means, and dependencies. The person edits the graph before anything starts. |
| 241 | - **Plan from their own agent.** The same operations are MCP tools, so a |
| 242 | person can plan in their own Claude Code session and create the project |
| 243 | from there. |
| 244 | - **The brief stays the source of truth.** Editing it later re-plans: new |
| 245 | issues are added, obsolete ones are closed. |
| 246 | |
| 247 | ### Seeing what moved |
| 248 | |
| 249 | - **Project page.** The outcome, the issue graph coloured by state, and how |
| 250 | many of its issues have landed with their required checks passing, |
| 251 | compared with when the project started. |
| 252 | - **Digest.** An agent-written summary per project and per person: what |
| 253 | merged, what is blocked on whom, which conflicts were resolved, what it |
| 254 | cost. |
| 255 | - **Timeline.** Every event (push, steer, check, conflict, merge) in order, |
| 256 | each linked to the session and the person or agent behind it. |
| 257 | |
| 258 | ## One session, any surface |
| 259 | |
| 260 | A session belongs to g1t, not to the device it started on. The browser, a |
| 261 | phone and Claude Code are views of the same session. |
| 262 | |
| 263 | - **Browser and phone.** The site is a responsive, installable web app with |
| 264 | push notifications. Everything a person does (brief, steer, answer, |
| 265 | approve, merge) works there. |
| 266 | - **Claude Code.** Through `mcp.g1t.sh` and the CLI hooks, a local session is |
| 267 | a g1t session: its transcript syncs as it runs and it appears in mission |
| 268 | control like any other. |
| 269 | - **Moving a session.** A local session can be sent to the cloud: a hosted |
| 270 | agent takes over the fork and the transcript and continues, so the laptop |
| 271 | can close. A hosted session can be pulled down: the CLI checks out the fork |
| 272 | and resumes it in local Claude Code with its history. |
| 273 | - **Limit.** A session running only on a laptop stops when the laptop does. |
| 274 | It can be steered between turns but not continued until it is moved or the |
| 275 | laptop is back. |
| 276 | |
| 277 | ## For people who do not write code |
| 278 | |
| 279 | - **Documents are first-class.** Specs, guides, policies and decisions live |
| 280 | in Docs, its own mode (docs/WORKSPACE.md, "Docs"), not a tab on a |
| 281 | project: rendered pages, edited in the browser like a document, with |
| 282 | inline comments, and filtered by the project they are about. "Suggest a change" is an |
| 283 | pull request and "publish" is merge, without git vocabulary. |
| 284 | - **Document issues.** "Write the onboarding guide for the billing API" is |
| 285 | an issue. Its Definition of done is a checklist judged by a reviewer agent |
| 286 | instead of a workflow. Agents draft and revise; people comment and approve. |
| 287 | - **Templates.** Product brief, RFC, decision record. A filled-in template is |
| 288 | a brief the planner can turn into a project. |
| 289 | - **Explain.** Ask about any repo, project or change in plain language and |
| 290 | get an answer with links to the code and sessions behind it. |
| 291 | - **Living documentation.** g1t generates "how this works" pages from the |
| 292 | code and keeps them current. When a merged change contradicts a document, |
| 293 | an issue opens to update it. |
| 294 | - **See it, don't read it.** Every pull request on a deployable repo gets a |
| 295 | preview URL (Workers Builds from the pull request's fork), so an approver clicks |
| 296 | through the result instead of reading a diff. Changes are also summarised |
| 297 | in plain language. |
| 298 | - **Roles.** A person can plan and approve work without ever cloning a |
| 299 | repo. The roles that were sketched here map onto the five repository |
| 300 | roles that are built (see "Access" under what is built): a viewer is |
| 301 | Read, a commenter is Read (anyone with Read opens issues and comments), |
| 302 | a planner is Triage (labels, milestones, assigning, closing) or Write |
| 303 | where planning spends compute, and an approver is Write (reviews count |
| 304 | and merges). Workspace-wide, a member may also be a billing manager or a |
| 305 | security manager. |
| 306 | |
| 307 | ## The macro view |
| 308 | |
| 309 | The hierarchy above a single repo: |
| 310 | |
| 311 | | Level | What it is | |
| 312 | | --- | --- | |
| 313 | | **Workspace** | A company or team: its people, repos, agents, budget and policies. | |
| 314 | | **Initiative** | A business outcome with an owner and measurable results, e.g. "move billing to usage-based pricing". Spans any number of repos. | |
| 315 | | **Outcome** | One deliverable inside an initiative: a brief and its graph of issues (shown as **Plan**). Called "project" before 2026-10-04; that name now means what [Projects](#projects) describes. | |
| 316 | | **Issue / Pull request** | As above. An issue may touch several repos; a pull request for it then holds one fork per repo and they land together. | |
| 317 | |
| 318 | How it feeds up, and what is built: |
| 319 | |
| 320 | - **A workspace is the unit everything belongs to.** Repositories, people, |
| 321 | access tokens, and later projects, budgets and policies are the |
| 322 | workspace's, never a person's. An account owns nothing; its first step |
| 323 | after confirming its email is creating a workspace, and the site sends it |
| 324 | there from wherever it was going. |
| 325 | - **One namespace.** Usernames and workspaces share one set of names, as on |
| 326 | Docker Hub and npm. A username is reserved for its owner's workspace, so |
| 327 | `g1t.sh/<name>` never means two things. |
| 328 | - **The workspace page is the roll-up.** `g1t.sh/<workspace>` shows its |
| 329 | repositories with their open issues and pull requests, and the pull |
| 330 | requests in progress across all of them. Projects and initiatives will |
| 331 | roll up to the same page. Its own pages live under `/<workspace>/-/` |
| 332 | (people, access tokens, settings), which no repository can be named. |
| 333 | - **Workspace access tokens instead of service accounts.** A workspace has |
| 334 | tokens of its own, in the same table and code path as personal ones. One |
| 335 | acts as the workspace, with a member's rights in that workspace only (the |
| 336 | Write role on its repositories; Admin only when an owner ticks it at |
| 337 | creation, `access_tokens.admin`, identity/0034), records who made it and |
| 338 | when it was last used, and keeps working when that person leaves. CI, |
| 339 | integrations and automations use these. Until 2026-10-08 the code gave |
| 340 | them Admin on every repository, which the security audit found let any |
| 341 | workspace token manage webhooks; code, this plan and the docs now agree. |
| 342 | |
| 343 | ### Portfolio |
| 344 | |
| 345 | One page answers "where is the business" across every initiative: |
| 346 | |
| 347 | - **Health** per initiative: on track, at risk, or blocked, derived from |
| 348 | facts (checks passing, issues stalled, questions waiting on a person), |
| 349 | not self-reported. |
| 350 | - **Progress** as measurable results: required checks passing, issues |
| 351 | merged out of planned, and the trend since the start. |
| 352 | - **Forecast** from actual throughput: at the current rate, when the |
| 353 | remaining issues land. |
| 354 | - **Spend** in tokens and dollars against a budget, per initiative. |
| 355 | - **Waiting on people**: every decision or approval a person owes, by name. |
| 356 | - **Roadmap**: initiatives laid out as now, next, later, with optional |
| 357 | time-boxed cycles for teams that work in sprints. |
| 358 | |
| 359 | ### Status without asking |
| 360 | |
| 361 | - **Standup.** An agent writes a daily report per initiative and one for the |
| 362 | whole workspace: what merged, what changed direction, what is at risk and |
| 363 | why, what needs a person. Delivered by email or webhook. |
| 364 | - **Ask.** A question box over the full event log and all sessions: "what |
| 365 | happened on the billing migration since Monday?" answers with links to the |
| 366 | sessions and commits behind each claim. |
| 367 | |
| 368 | ### Long-running agents |
| 369 | |
| 370 | Work that runs for days needs supervision that does not depend on someone |
| 371 | watching. |
| 372 | |
| 373 | - **Checkpoints.** A long pull request reports milestones against its issue, so |
| 374 | progress is visible before anything merges. |
| 375 | - **Stall and drift detection.** A pull request with no meaningful progress, or |
| 376 | whose changes have wandered away from its issue, is flagged and can be |
| 377 | stopped or re-briefed automatically. |
| 378 | - **Budgets.** Hard limits on spend and time per pull request, project and |
| 379 | initiative. |
| 380 | |
| 381 | ### Context hub |
| 382 | |
| 383 | Agents working across repos and days need context that outlives any one |
| 384 | session and reaches beyond the code. The context hub is one place an agent |
| 385 | asks, whatever the source. |
| 386 | |
| 387 | | Source | What it holds | How it gets there | |
| 388 | | --- | --- | --- | |
| 389 | | **Memory** | Decisions, conventions, gotchas, facts about systems | Written by agents and people in g1t | |
| 390 | | **Code and sessions** | The repos, and the reasoning behind every change | Already in g1t | |
| 391 | | **Connected sources** | Jira and Linear tickets, Notion and Confluence pages, Google Drive documents, Slack threads, Sentry issues | Connectors, authorised per workspace | |
| 392 | |
| 393 | How it behaves: |
| 394 | |
| 395 | - **One search.** An agent asks a question and gets ranked results across |
| 396 | all sources, each labelled with where it came from, who wrote it, and how |
| 397 | fresh it is. |
| 398 | - **Connected sources stay where they are.** g1t indexes them for search and |
| 399 | fetches the current version when an agent opens one. The external system |
| 400 | remains the source of truth, and a link placed on an issue ("see |
| 401 | JIRA-482", a Notion URL) is pulled into the agent's starting context. |
| 402 | - **Permissions carry over.** A connector only exposes what the connecting |
| 403 | account can see, and a workspace admin chooses which spaces, projects or |
| 404 | channels are included. |
| 405 | - **External content is untrusted.** A ticket or page can contain text meant |
| 406 | to manipulate an agent. It is marked as reference material, never treated |
| 407 | as instructions. |
| 408 | - **Documentation is separate.** Context is what agents know; documentation |
| 409 | is what people read, and it is generated from context and code. |
| 410 | |
| 411 | Memory is the part of the hub that g1t owns and agents write to: |
| 412 | |
| 413 | - **Memory is written freely.** Any agent or person adds an entry with one |
| 414 | call: a decision, a convention, a gotcha, a fact about a system. No review |
| 415 | gate. Each entry records who wrote it, from which session, and when. |
| 416 | - **It is still a repository.** Each workspace has a memory repo in |
| 417 | Artifacts, so every write is a commit: versioned, attributable, and |
| 418 | revertible. |
| 419 | - **It is kept healthy by an agent.** A consolidation agent merges |
| 420 | duplicates, retires entries that newer ones contradict, and flags |
| 421 | conflicts it cannot settle. People can pin an entry (agents may not change |
| 422 | it), correct it, or retract it. |
| 423 | - **Agents read it.** Every session starts with the context relevant to its |
| 424 | issue, found by search, and can query more through MCP. |
| 425 | - **Updates are events.** A memory write or a change in a connected source |
| 426 | is an event, so "when context changes, update the affected docs" is an |
| 427 | automation, on by default. |
| 428 | - **It is scoped inside the workspace.** Some context applies to the whole |
| 429 | workspace, some to one initiative, project or repo, so an agent gets what |
| 430 | applies to its work. |
| 431 | - **It never crosses workspaces.** A workspace is the isolation boundary: its |
| 432 | context, sessions and private repos are invisible to every other |
| 433 | workspace, and an agent's token is bound to one workspace. |
| 434 | |
| 435 | ## Working in g1t |
| 436 | |
| 437 | - **Mission control.** The signed-in home page: every running session, every |
| 438 | issue waiting on a decision, and what merged, across all repos. |
| 439 | - **Outcomes.** Group issues across repos toward one result and track how |
| 440 | many are open, racing, or merged. (What [Projects](#projects) means is |
| 441 | below.) |
| 442 | - **Steering.** Send a message to a running pull request, or to all pull requests on an |
| 443 | issue at once, without stopping them. |
| 444 | - **Automations.** Rules that start work without a person (next section). |
| 445 | |
| 446 | ## Automations and integrations |
| 447 | |
| 448 | > **2026-10-03:** g1t's own `.g1t/automations` format was built and then set |
| 449 | > aside at the user's request ("let's just copy GitHub Actions on that for the |
| 450 | > time being"). Automation on g1t is GitHub Actions workflows in |
| 451 | > `.g1t/workflows/`; the format below is kept for later. |
| 452 | |
| 453 | An automation is **when** an event happens, **if** conditions hold, **do** |
| 454 | something. They are defined as files in the repo (`.g1t/automations/`), the |
| 455 | way GitHub Actions workflows are, and can also be built in the UI. |
| 456 | |
| 457 | ### Events that can trigger one |
| 458 | |
| 459 | | Source | Examples | |
| 460 | | --- | --- | |
| 461 | | Git | push, merge, check failed, `main` moved | |
| 462 | | g1t | issue opened, pull request stalled, context updated, handoff declined, budget reached | |
| 463 | | Time | cron schedule | |
| 464 | | Integrations | Sentry issue, PagerDuty incident, Linear or Jira ticket, Slack message or mention, GitHub issue, Stripe event | |
| 465 | | Anything else | a signed generic webhook, or an email to a per-repo address | |
| 466 | |
| 467 | **Actions**: open an issue (optionally assigning N agents to it), message |
| 468 | a running pull request, update documentation, notify, call a |
| 469 | webhook, write back to the source system. |
| 470 | |
| 471 | **Example: Sentry.** A new production error arrives. The automation opens an |
| 472 | issue labelled `bug`, with the stack trace, release and frequency in its |
| 473 | description. Why-blame |
| 474 | finds the session that wrote the failing line, so the fixing agent starts |
| 475 | with the original reasoning. When the fix merges, g1t comments on the Sentry |
| 476 | issue and resolves it. |
| 477 | |
| 478 | ### Rules every automation obeys |
| 479 | |
| 480 | - **Deduplication.** The same Sentry issue firing 500 times maps to one |
| 481 | issue. |
| 482 | - **Limits.** Concurrency and budget caps per automation. |
| 483 | - **Loop protection.** Work started by an automation cannot retrigger the |
| 484 | same automation without a person in between. |
| 485 | - **External input is untrusted.** A webhook payload can contain text written |
| 486 | by an attacker. Agents started by external events run with reduced |
| 487 | permissions and cannot merge without the repo's approval rule passing. |
| 488 | |
| 489 | **Checks** are the other half of what GitHub Actions does: build and test |
| 490 | commands declared in `.g1t/checks.yaml`, run in sandboxes on every pull request |
| 491 | and on every combined state in the landing queue. |
| 492 | |
| 493 | ### Tokens, scopes and packages the GitHub way (built 2026-10-08) |
| 494 | |
| 495 | > **2026-10-08 (owner):** "emulate all of what GitHub does for scope |
| 496 | > mapping and packages." GitHub's current behaviour is the spec. |
| 497 | |
| 498 | This **reverses identity/0023**, which retired a token's reach to some |
| 499 | workspaces or repositories and left classic tokens only. The reason it is |
| 500 | reversed: the owner chose GitHub parity, and GitHub has fine-grained tokens |
| 501 | beside classic ones, with workspaces (organizations) governing both. |
| 502 | |
| 503 | - **Fine-grained personal access tokens** (identity/0034, |
| 504 | `services/identity/src/token_reach.rs`, `g1t_contracts::fine_grained`): |
| 505 | one resource owner (a workspace the person belongs to, or their own |
| 506 | account), all, selected (up to 50, by repository id) or only public |
| 507 | repositories, and a level per permission under GitHub's names (contents, |
| 508 | metadata, issues, pull_requests, actions, workflows, checks, statuses, |
| 509 | deployments, pages, environments, secrets, variables, webhooks, |
| 510 | administration, packages, security_events; members, |
| 511 | workspace_administration, self_hosted_runners, workspace_secrets, |
| 512 | workspace_webhooks, workspace_billing, models; email_addresses, starring, |
| 513 | notifications; g1t's agents and memory). Each level maps onto g1t's |
| 514 | scopes, which the token stores, so every check that reads scopes |
| 515 | (`scopes::decide` for the API and MCP, `decide_git`, `decide_packages`) |
| 516 | reads them unchanged. They must expire, within 366 days. On each use, |
| 517 | identity cuts the resolved person down to the token's reach |
| 518 | (`apply_reach`); `access::granted` gives no role outside it, so a public |
| 519 | repository elsewhere still reads and nothing more. |
| 520 | - **Governance** (`token_policies`, `token_workspace_revocations`): per |
| 521 | workspace, allow classic, allow fine-grained, require approval (on by |
| 522 | default, as GitHub's; owners' own tokens never wait), the longest |
| 523 | lifetime, and forbidding tokens that never expire. Owners see every |
| 524 | member's token that can reach the workspace, approve or deny pending |
| 525 | fine-grained ones (inbox: `token.approval_requested` and |
| 526 | `token.approval_reviewed`, the inbox's first notices about no |
| 527 | repository), and revoke one there. REST and MCP for owners; audited as |
| 528 | `token.*`. |
| 529 | - **Workflow files** need `workflow_files:write` (GitHub's `workflow` |
| 530 | scope; the `workflows` permission) from any token, checked commit by |
| 531 | commit on push (`services/repos/src/workflow_gate.rs`) and on files g1t |
| 532 | writes for a token. A job's token never has it. g1t's agents push with |
| 533 | run credentials, not tokens, and are not gated by it; their work arrives |
| 534 | as pull requests people review. |
| 535 | - **Workspace tokens** have Write unless an owner gives Admin at creation. |
| 536 | - **Deploy keys** (identity/0035): per repository, read-only unless write |
| 537 | is ticked; resolved to a principal bound to the one repository. |
| 538 | Serving git over SSH is still to come, so nothing uses them yet. |
| 539 | - **Packages** (packages/0006, `services/packages/src/access.rs` and |
| 540 | `settings.rs`): per-package roles (read, write, admin) for people and |
| 541 | teams, with "inherit access from the linked repository" (on by default); |
| 542 | "Manage Actions access", which a job's token is held to (its own linked |
| 543 | repository writes; any other repository needs an entry, added |
| 544 | automatically for the repository whose job first publishes an unlinked |
| 545 | package); linking by `org.opencontainers.image.source` (manifest |
| 546 | annotation or image label, same workspace, pusher may push there); 30-day |
| 547 | soft delete of packages and versions, registry deletes included (the name |
| 548 | and version stay reserved), restore, and a purge in the hourly cron; a |
| 549 | settings tab and a "Deleted packages" view; 17 REST operations and one |
| 550 | `package` MCP tool (reads `packages:read`; settings and access |
| 551 | `packages:write` with the package's Admin role; delete and restore |
| 552 | `packages:delete`); and download counts per version in every registry. |
| 553 | Existing unlinked packages have no Actions access entries, so workflows |
| 554 | that used them through `G1T_TOKEN` need one added. |
| 555 | |
| 556 | ### Keeping workflow runs safe (built 2026-10-08) |
| 557 | |
| 558 | An audit of g1t Actions found a job's token was a full-access workspace |
| 559 | token, environments had no protection, outside pull requests ran at once, |
| 560 | the cache could be poisoned across branches, a job's token could set off |
| 561 | more runs, and masking missed multi-line and encoded secrets. Now: |
| 562 | |
| 563 | - **The job's token** (`G1T_TOKEN`, `GITHUB_TOKEN`) is minted per job by |
| 564 | identity (`create_job_token`, migration identity/0030): it reaches its |
| 565 | repository only (`TokenAccess.repo`, enforced by the API, git and the |
| 566 | registries), carries the scopes its `permissions:` map to |
| 567 | (`g1t_actions::permissions`), is revoked when the job ends, and its |
| 568 | writes are audited with the run as `run_kind: workflow_job`. Without |
| 569 | `permissions:` it gets the repository's default, the GitHub way: |
| 570 | repositories that existed when actions/0007 ran keep read and write, |
| 571 | newer ones take their workspace's default (read-only unless an owner |
| 572 | says), and a workspace can cap every repository at read-only. An outside |
| 573 | pull request's is read-only. "Allow g1t Actions to create and approve |
| 574 | pull requests" (repository and workspace, off by default) decides whether |
| 575 | the token may open or approve pull requests. OIDC (`id-token: write`) |
| 576 | reads the same permissions model. |
| 577 | - **No loops.** Work and repos mark the events a job's token causes |
| 578 | (`causedByJob`), carried on to a pull request it moves; the actions |
| 579 | service starts nothing for them. `workflow_dispatch` and |
| 580 | `repository_dispatch` (now sent by `POST {repo}/dispatches`) still start |
| 581 | runs. |
| 582 | - **Environments' protection rules** (actions/0007): required reviewers |
| 583 | (people or teams, up to six, optionally not whoever started the run), a |
| 584 | wait timer, which branches and tags may deploy, and admin bypass. A job |
| 585 | naming one is `pending` once its needs are done, its environment read |
| 586 | then (an expression included); reviewers hear in the inbox |
| 587 | (`deployment.review_requested`) and approve on the run's page or through |
| 588 | `pending_deployments`; secrets are read only when the job starts. |
| 589 | - **Approval for outside pull requests**, by a repository policy |
| 590 | (first-time contributors, outside contributors (the default), or every |
| 591 | external contributor): such runs are `action_required` until someone with |
| 592 | Write approves them. |
| 593 | - **The cache is scoped by ref** (own, then the pull request's base, then |
| 594 | the default branch; outside pull requests save where nothing else reads) |
| 595 | and versioned by its paths and compression (0006's toolkit `version`, |
| 596 | which g1t's runner now sends too); g1t's `actions/cache` and the |
| 597 | toolkit's protocols share one scope rule. Entries from before were |
| 598 | expired. |
| 599 | - **Masking** covers each line of a multi-line secret, base64 at every |
| 600 | offset and JSON-escaped forms; outputs holding a secret are withheld and |
| 601 | annotations masked. |
| 602 | - A job's own `concurrency:` is honoured, `create` runs on new branches and |
| 603 | tags, and `on: delete` says plainly that it never runs yet. |
| 604 | |
| 605 | ### Docker in workflow jobs (built 2026-10-08) |
| 606 | |
| 607 | > **2026-10-08:** "Why didn't we give CI docker then? We need GitHub |
| 608 | > Actions functionality maxxed baby but with all the good good security |
| 609 | > etc." The trigger: `deploy.yml`'s runner-image job needs `docker build` |
| 610 | > and `docker push`, and failed on hosted runners. |
| 611 | |
| 612 | **What Cloudflare Containers allow** (their FAQ, updated 2026-10-05, and |
| 613 | the Docker-in-Docker guide and example it links): |
| 614 | |
| 615 | - Docker runs inside a container: `docker:dind`, with `dockerd` as |
| 616 | **root**. A rootless Engine does not start there. |
| 617 | - **No iptables**: `--iptables=false --ip6tables=false`, or the Engine |
| 618 | fails setting up its rules. Containers with the `durable_object` |
| 619 | scheduling policy (ours: each sandbox is a Durable Object's) cannot turn |
| 620 | IP forwarding on either: `--ip-forward=false`, or the Engine exits. |
| 621 | - So **a bridge network has no way out**: the guide's answer is |
| 622 | `--network=host` for `docker run` and `docker build`, which gives |
| 623 | containers the outer container's network. |
| 624 | - Built images and containers are lost when the sandbox stops. |
| 625 | |
| 626 | **What was found by trying** (Docker Engine 29.8.2 in a privileged |
| 627 | container standing in for a sandbox, with the same flags): |
| 628 | |
| 629 | - `--bridge=none` makes BuildKit's `RUN` steps fail outright ("network |
| 630 | bridge not found"); with the default bridge they run with no route out. |
| 631 | Containers default to the bridge too. The default bridge is created |
| 632 | fine without iptables, as the FAQ's own example relies on. |
| 633 | - The overlay snapshotter does not work on an overlay root filesystem, and |
| 634 | the containerd image store does not fall back by itself: the Engine |
| 635 | starts, then every container fails to mount. Whether a sandbox's disk |
| 636 | takes overlays is not documented, so the runner tries a mount first and |
| 637 | uses `native` (plain copies) when it fails. `vfs` is not a name the |
| 638 | containerd store accepts. |
| 639 | - `--cpus` and `--memory` need cgroup v2 controllers handed down from a |
| 640 | cgroup with no processes, which `docker:dind`'s entrypoint does and a |
| 641 | plain `dockerd` does not. |
| 642 | - A `runc` earlier on the Engine's `PATH` is used both for containers (via |
| 643 | containerd's shim) and by BuildKit's executor, with the bundle's |
| 644 | `config.json` written before it runs. BuildKit's bridged steps carry |
| 645 | libnetwork's `libnetwork-setkey` prestart hook; `RUN --network=none` |
| 646 | does not. |
| 647 | - Buildx skips `type=gha` caches when the job has no GitHub cache service, |
| 648 | and the build succeeds without one. |
| 649 | - Registries' layer hosts: Docker Hub sends layers from |
| 650 | `production.cloudfront.docker.com` (and `production.cloudflare.docker.com`), |
| 651 | Quay from `cdn0N.quay.io`, Microsoft's from regional |
| 652 | `*.data.mcr.microsoft.com`, public ECR from a CloudFront host; |
| 653 | `mirror.gcr.io` serves its own. |
| 654 | |
| 655 | **What was built** (`crates/runner/src/docker`, `actions/containers.rs`): |
| 656 | |
| 657 | - **One Engine per job, started lazily.** The runner listens on |
| 658 | `/var/run/docker.sock` itself and starts `dockerd` (root, the flags |
| 659 | above, containerd image store, `mirror.gcr.io` first for Docker Hub) on |
| 660 | the first connection, or when the job has `services:` or `container:`. |
| 661 | A log line says it started and how long it took. |
| 662 | - **Containers on the job's network.** The socket is an API proxy: a |
| 663 | container that asks for a bridge or user network gets `host`; its names |
| 664 | (container name, aliases, Compose service, links) resolve to 127.0.0.1 |
| 665 | in later containers (`ExtraHosts`) and in the job's steps |
| 666 | (`/etc/hosts`); `-p 8080:80` is forwarded; `docker inspect` reports the |
| 667 | ports as published; `network connect` adds aliases. Sharing the job's |
| 668 | network is also what keeps the guardrails on every container: the |
| 669 | egress Worker sees their traffic as the job's. |
| 670 | - **A `runc` shim.** The runner binary, as `runc`: BuildKit steps bound for |
| 671 | a bridge lose the network namespace and the libnetwork hook (so they use |
| 672 | the job's network); in a guarded job every container (run, exec, build |
| 673 | step) gets the egress certificate at `/dev/g1t-egress` and the |
| 674 | variables that point tools at it. `/dev` is the container's own tmpfs, |
| 675 | so none of it lands in a layer; checked by saving a built image. |
| 676 | - **Job features:** `services:` (pull, credentials, health waits, logs at |
| 677 | the end, `job.services.*`), `container:` (steps and JavaScript actions |
| 678 | through `docker exec`, Node mounted from the runner, Alpine falls back to |
| 679 | running actions beside it), `docker://` steps and Dockerfile actions in |
| 680 | GitHub's `/github/*` layout, `docker/setup-buildx-action` answered |
| 681 | natively (the job's Engine is the builder), sign-in to g1t's registry |
| 682 | with the run's token. |
| 683 | - **Kill switch:** the runner Worker's `DOCKER` var (`off`). |
| 684 | |
| 685 | **Rejected:** rootless Docker or BuildKit (does not start in Containers); |
| 686 | Podman or buildah with `vfs` (no better networking, less compatible, slow); |
| 687 | a standalone `buildkitd --oci-worker-net=host` as the default builder |
| 688 | (images not in the Engine's store, so `FROM` a just-built image and |
| 689 | `docker run` of a build fail without `--load` round trips); a `docker` CLI |
| 690 | wrapper adding `--network=host` (misses Compose, SDKs and testcontainers, |
| 691 | which speak the API). |
| 692 | |
| 693 | **Not yet:** |
| 694 | |
| 695 | - Seen on Cloudflare itself: whether a sandbox's disk takes overlays, |
| 696 | `--privileged`, and the first deploy's pull of the base from |
| 697 | `registry.cloudflare.com` (its layer host may need a workflow-only line). |
| 698 | - `type=gha` build caches backed by g1t's Actions cache. |
| 699 | - Multi-platform builds (QEMU's `binfmt_misc` in a sandbox). |
| 700 | - Docker for agents and checks, not just workflow jobs. |
| 701 | - `runner-base.yml` on g1t's machines: the base's apt step needs |
| 702 | `Acquire::https::CAInfo` pointed at the egress certificate first. |
| 703 | - A deploy that appends the runner binary as a layer through the registry |
| 704 | API, with no Docker and no 3 GB pull. |
| 705 | |
| 706 | Agents can also reach integrations directly: an agent definition lists MCP |
| 707 | servers (Sentry, Linear and so on) it may use while working. |
| 708 | |
| 709 | ### Workflows: the toolkit, OIDC and artifacts |
| 710 | |
| 711 | > **2026-10-08:** built so that workflows that deploy, cache and pass files |
| 712 | > run unmodified. |
| 713 | |
| 714 | - **The toolkit's services.** Every job gets `ACTIONS_RUNTIME_TOKEN` (a |
| 715 | JWT whose `scp` names its run and job, signed with a key derived from |
| 716 | the job's own token, so nothing new is kept), `ACTIONS_RESULTS_URL`, |
| 717 | `ACTIONS_CACHE_URL` and `ACTIONS_CACHE_SERVICE_V2`. The API answers the |
| 718 | cache's Twirp service (v2) and its older REST protocol, the artifact |
| 719 | Twirp service, and the signed blob links they hand out (a subset of |
| 720 | Azure Blob's protocol mapped onto R2 multipart uploads), from the same |
| 721 | cache and artifact rows g1t's own runner uses. As the clients' source |
| 722 | reads, `@actions/cache` and `@actions/artifact` treat any server |
| 723 | but github.com as GitHub Enterprise Server, so the cache client speaks |
| 724 | the older protocol and the artifact client refuses to run. g1t's runner |
| 725 | therefore keeps handling `actions/upload-artifact`, `download-artifact` |
| 726 | and `upload-artifact/merge` itself; the Twirp artifact service is there |
| 727 | for clients that do not check. |
| 728 | - **OIDC.** The issuer is `{API}/actions/oidc`, the API's own host, with |
| 729 | discovery, JWKS (RFC 7638 `kid`s, a previous key published while |
| 730 | rotating) and a token endpoint for `core.getIDToken`. Claims follow |
| 731 | GitHub's. A job gets one only when its permissions (or its workflow's) |
| 732 | give `id-token: write`, and never for an untrusted run. The permission |
| 733 | check reads only `id-token` (`services/actions/src/runtime.rs`, |
| 734 | `id_token_permitted`), the seam for the full `permissions:` model. |
| 735 | - **Artifacts** moved from KV to R2 (`a/` in the cache bucket), with rows |
| 736 | in the actions service: numeric ids, 5 GiB each and 10 GiB a run, |
| 737 | zipped by the runner, `retention-days` up to the repository's setting |
| 738 | (1 to 90, 14 by default), `overwrite`, `compression-level`, patterns, |
| 739 | merging and other runs of the same repository. The REST artifacts API and |
| 740 | the `workflow` tool's artifact actions follow GitHub's shapes; the run's |
| 741 | page lists them with size and expiry, with download and delete. Their |
| 742 | storage is charged with the cache's. |
| 743 | - **Later:** the toolkit's older artifact protocol (`upload-artifact@v3` |
| 744 | inside other actions), downloads from other repositories, and npm |
| 745 | trusted publishing, which depends on npm accepting g1t's issuer. |
| 746 | |
| 747 | ### Actions parity: other repositories, triggers, step timeouts (built 2026-10-08) |
| 748 | |
| 749 | - **Other repositories' actions and reusable workflows** |
| 750 | (`services/actions/src/reach.rs`, actions/0008): `uses: owner/repo@ref`, |
| 751 | `owner/repo/path@ref` and `jobs.<id>.uses: owner/repo/.g1t|.github/workflows/x.yml@ref` |
| 752 | are looked for on g1t first, as the calling workspace sees them. Same |
| 753 | repository or public: used. Private: only from a private repository of |
| 754 | the same workspace, when its **Settings → Actions → Access** (`access_level`, |
| 755 | `GET`/`PUT …/actions/permissions/access`, MCP `get_access`/`set_access`) |
| 756 | says `organization`; a job fetches such an action with a read-only token |
| 757 | for that repository, revoked with the job (`job_action`, the runner's |
| 758 | `POST /actions/jobs/{job}/action`). Not on g1t: actions from GitHub as |
| 759 | before, reusable workflows from a public GitHub repository. A `./` call |
| 760 | inside a called workflow reads from that workflow's own repository. |
| 761 | - **Secrets for called workflows** follow GitHub: none but the job token |
| 762 | unless the caller passes `secrets:` by name or `secrets: inherit`; |
| 763 | required secrets are checked before the call; a called job's |
| 764 | `environment:` reads that environment's secrets over what was passed. The |
| 765 | mapping is kept with the called jobs and read when each starts, so no |
| 766 | secret is stored. (Before, same-repository called workflows read every |
| 767 | repository secret.) |
| 768 | - **Triggers:** `release` (created, published, released, prereleased, |
| 769 | edited, unpublished, deleted; repos now publishes `release.*`), |
| 770 | `deployment` and `deployment_status` (from the deployments service's |
| 771 | events; ones an Actions job or a job token made are marked |
| 772 | `causedByJob` and start nothing), `pull_request` `reopened` and |
| 773 | `converted_to_draft`, `issue_comment` `edited` and `deleted` (work |
| 774 | publishes `pull.reopened`, `pull.converted_to_draft`, `comment.edited` |
| 775 | and `comment.deleted`). |
| 776 | - **`timeout-minutes` on every step**, `uses:` included: the runner keeps a |
| 777 | step deadline every process it starts stops by, nested composite steps |
| 778 | taking the nearer one. |
| 779 | - **Not yet:** a deployment's `ref` that is neither a branch nor a commit |
| 780 | is read as a tag; `on: delete`. |
| 781 | |
| 782 | ### Runs: summaries, attempts, cancelling, logs and badges (built 2026-10-08) |
| 783 | |
| 784 | GitHub Actions parity on the run itself: |
| 785 | |
| 786 | - [x] **Job summaries.** The runner sends each step's |
| 787 | `$GITHUB_STEP_SUMMARY`, masked, as a `summary` report (1 MiB a step, |
| 788 | 20 steps a job, kept in `job_summaries`, actions/0009); the run's page |
| 789 | renders them as sanitised Markdown, a card per job. |
| 790 | - [x] **Attempts and re-runs.** A re-run is a new attempt that keeps the |
| 791 | one before (`run_attempts`, `job_attempts`; a re-run job's logs and |
| 792 | summary move to `{job}.{attempt}`, which is its id when that attempt is |
| 793 | viewed). Re-run all, failed, or one job (`POST …/jobs/{job}/rerun`) with |
| 794 | the jobs that need it; a matrix or a called workflow runs again whole. |
| 795 | Debug re-runs set `RUNNER_DEBUG=1`, `ACTIONS_STEP_DEBUG`, |
| 796 | `ACTIONS_RUNNER_DEBUG` and `runner.debug`; the runner then shows |
| 797 | `::debug::` lines and how each step's `if:` read. An attempt picker on |
| 798 | the run's page, `attempt` on `get_workflow_run` and |
| 799 | `…/runs/{id}/attempts/{n}`. |
| 800 | - [x] **Graceful cancel.** A running job gets `cancel_requested_at`, |
| 801 | told in the answer to its next report (a quiet step pings every 10 s): |
| 802 | the step's process group gets SIGINT, SIGTERM at 7.5 s, SIGKILL at 10 s; |
| 803 | then only `always()`/`cancelled()` steps and post steps run, and the job |
| 804 | ends `cancelled`. Hard-stopped after 5 minutes; cancelling again or |
| 805 | `…/force-cancel` stops at once. |
| 806 | - [x] **Logs.** Search on the run's page (matching lines, groups opened); |
| 807 | one job's log as text (`…/jobs/{job}/log.txt`, API |
| 808 | `…/jobs/{job}/logs?format=text`) and an attempt's as a zip laid out as |
| 809 | GitHub's (`…/runs/{id}/logs.zip`, API `…/runs/{id}/logs`), up to 24 MiB. |
| 810 | - [x] **Status badges** at `/{ws}/{repo}/actions/workflows/{file}/badge.svg` |
| 811 | with `branch` and `event`; public repositories' for anyone (cached a |
| 812 | minute), private ones' only for viewers who can see them. "Create status |
| 813 | badge" on the workflow's page gives the Markdown. |
| 814 | - Not yet: re-running one combination of a matrix alone; signals into a |
| 815 | job container's processes on cancel (they reach `docker exec` only). |
| 816 | |
| 817 | ### Runner image: Java, .NET and Ruby (built 2026-10-08) |
| 818 | |
| 819 | The base (`services/runner/base/Dockerfile`) adds Temurin 21, the .NET 8 |
| 820 | SDK and Ruby 3.3, placed where the setup actions look so common workflows |
| 821 | run unmodified and download nothing: |
| 822 | |
| 823 | - **Java** in `RUNNER_TOOL_CACHE/Java_Temurin-Hotspot_jdk/<semver, + as |
| 824 | ->/x64` with `x64.complete`; `JAVA_HOME`, `JAVA_HOME_21_X64` and `PATH` |
| 825 | set. `actions/setup-java` (`temurin`, `21`) resolves it from the cache. |
| 826 | - **.NET** in `/usr/share/dotnet` (setup-dotnet's Linux install dir), |
| 827 | owned by `node`; `DOTNET_ROOT` set, telemetry off. `setup-dotnet` with |
| 828 | `8.0.x` keeps it while it is the newest 8.0 SDK, else installs beside it. |
| 829 | - **Ruby** built from source into `RUNNER_TOOL_CACHE/Ruby/<v>/x64` with |
| 830 | `x64.complete`, on `PATH`. On Debian, `ruby/setup-ruby` counts as |
| 831 | self-hosted and uses only the tool cache, so any version but 3.3 fails |
| 832 | (documented in limitations). |
| 833 | |
| 834 | **`gh`: not installed.** With `GH_HOST=g1t.sh`, `gh` treats g1t as |
| 835 | GitHub Enterprise Server: REST under `https://g1t.sh/api/v3` and GraphQL at |
| 836 | `https://g1t.sh/api/graphql`. Both are 404 today (the API is REST at |
| 837 | `api.g1t.sh`, and `GITHUB_GRAPHQL_URL` is empty), and `pr`, `issue`, `repo` |
| 838 | and `run` are GraphQL-first, so even `gh api` alone would need the |
| 839 | `/api/v3` prefix. Jobs call the API with `curl` and `$GITHUB_API_URL` |
| 840 | (documented in the Actions guide). |
| 841 | |
| 842 | **Later:** to make `gh` useful, `g1t.sh/api/v3/*` proxying to the REST API |
| 843 | (enough for `gh api` and `gh auth status`), then a GraphQL subset for the |
| 844 | `pr`/`issue` read paths. Ship `gh` in the base only once those exist. |
| 845 | More preinstalled Rubies (3.2, 3.4) if workflows ask, at roughly 75 MB |
| 846 | each. `setup-dotnet@v5` first installs the current LTS .NET runtime (10, |
| 847 | a 36 MB download) every run before finding SDK 8 already there; |
| 848 | preinstalling that runtime would skip it. |
| 849 | |
| 850 | **Size:** the base went from 3.18 GB to 4.52 GB as `docker image inspect` |
| 851 | reports it (813 MB to about 1.2 GB compressed): Temurin 308 MB (without |
| 852 | `src.zip`), .NET 512 MB (without the SDK's translations), Ruby 74 MB, |
| 853 | headers and ICU 44 MB. |
| 854 | |
| 855 | ## A repository that maintains itself |
| 856 | |
| 857 | > **2026-10-04:** the user asked for Dependabot, GitHub Advanced Security and |
| 858 | > Vercel-style deployments, "so you're not having to maintain shit and you're |
| 859 | > just pushing up agents that are delivering work consistently". |
| 860 | |
| 861 | GitHub reports problems and leaves the fix to you. In g1t, an agent opens an |
| 862 | issue for each problem, writes the fix, runs its checks, links a preview and |
| 863 | lands it through the queue. People only decide. |
| 864 | |
| 865 | ### Upkeep agents |
| 866 | |
| 867 | - **Dependency updates.** The file is `dependabot.yml` version 2, read from |
| 868 | the default branch at `.g1t/dependabot.yml` (or `.yaml`), then |
| 869 | `.github/dependabot.yml` (or `.yaml`); `.g1t/` wins when both exist, and |
| 870 | an imported repository's file works unchanged. Every option is read and |
| 871 | checked, each problem reported with its line and key on the Security page |
| 872 | and as the `g1t / dependabot.yml` status on pull requests that change the |
| 873 | file; a file with problems is not acted on. |
| 874 | - **Built (2026-10-07):** version updates for npm, cargo, gomod and pip: |
| 875 | schedules (all intervals, cron and natural phrases, time zones, a |
| 876 | picked time per repository), allow, ignore, cooldown (3 days by |
| 877 | default), groups (including across directories and `group-by`), |
| 878 | versioning strategies, open-pull-requests-limit, commit-message, |
| 879 | branch names, rebase-strategy, assignees, reviewers, private |
| 880 | registries filled from workflow secrets (npm, cargo, Go proxy, Python |
| 881 | index), and the `@g1t` comment commands. Pull requests come from g1t |
| 882 | with an `updated-dependencies` commit record and land through the |
| 883 | required checks; one that fails them is closed and becomes a |
| 884 | "needs code changes" issue assigned to g1t. |
| 885 | - **Security updates follow the same file:** ignore (and comment |
| 886 | ignores), allow names, `applies-to: security-updates` groups, |
| 887 | commit-message, assignees, reviewers, labels and milestone. Cooldown |
| 888 | and the open pull request limit do not apply. The Security updates |
| 889 | switch still turns them on and off. |
| 890 | - **Labels, milestone and target-branch** are applied to version |
| 891 | updates: `dependencies` and the ecosystem's label by default, missing |
| 892 | labels created; `target-branch` updates are made from that branch and |
| 893 | merge into it. |
| 894 | - **Not done yet:** one pull request for a multi-ecosystem group |
| 895 | (it opens one per ecosystem); registries that sign in with OIDC; |
| 896 | updating vendored copies; and version updates for the other |
| 897 | ecosystems (bundler, composer, docker, github-actions, gradle, maven, |
| 898 | nuget, terraform, uv and the rest are read and checked only). |
| 899 | - **Secret scanning.** Pushes are scanned for known token formats. A push |
| 900 | that adds a secret is refused with the file and line; one already in |
| 901 | history opens an issue to rotate it and remove it. |
| 902 | - **Vulnerability alerts.** Dependencies are matched against the OSV |
| 903 | database. Every alert links to the issue and pull request fixing it. |
| 904 | - **Code scanning.** A reviewer agent reads each pull request's diff for |
| 905 | security problems and leaves findings as review comments with a |
| 906 | suggested fix. Findings on `main` open issues. |
| 907 | - **A security page per repository** lists alerts, secrets and findings, |
| 908 | with the agent work on each, like GitHub's Security tab. |
| 909 | |
| 910 | All of these are event sources for the existing issue → agent → checks → |
| 911 | queue pipeline; they need no new kind of work. |
| 912 | |
| 913 | ### The security suite (built 2026-10-07) |
| 914 | |
| 915 | GitHub Advanced Security's depth, in g1t's shape (services/security, |
| 916 | `g1t_contracts::security_suite`, docs `guides/security/*`): |
| 917 | |
| 918 | - **Secret protection.** Custom patterns (repository and workspace; Rust |
| 919 | `regex`, linear time, size-limited; test strings; dry run over the |
| 920 | default branch) used by push protection, `commit_file` and history |
| 921 | scans. Bypass with a reason (false positive, used in tests, will fix |
| 922 | later), recorded on the alert and in the audit log; delegated bypass |
| 923 | (requests reviewed by owners and repository admins, through the inbox). |
| 924 | Validity checks for GitHub, GitLab, Stripe, Slack, npm, OpenAI, |
| 925 | Anthropic and SendGrid tokens, made by the repos service, which reads the |
| 926 | landed secret again: the value never leaves it except to the issuer. AWS |
| 927 | keys (need their secret key to sign) and webhook addresses (would post) |
| 928 | are the extension points left (`g1t_scan::validity::check_for`). |
| 929 | - **Code scanning.** SARIF 2.1.0 uploads → alerts with fingerprints (tool |
| 930 | partial fingerprints first), fixed when no longer reported; pull request |
| 931 | uploads → line comments and the `Code scanning` commit status, gated by a |
| 932 | per-repository threshold and required like any check. Starter workflow: |
| 933 | a scanner per language present, each uploading its own category: Bandit |
| 934 | (Python), gosec (Go), ESLint + eslint-plugin-security with the SARIF |
| 935 | formatter (JS/TS), Clippy + clippy-sarif (Rust); all install from the |
| 936 | registries the runner's egress already allows. Semgrep's registry rules |
| 937 | and the Opengrep rules fork are not usable in a paid feature, so neither |
| 938 | is used. "Fix with g1t" opens an issue and runs the agent. |
| 939 | - **Supply chain.** Dependency graph (direct/transitive where the lockfile |
| 940 | says, npm licenses), SPDX 2.3 SBOM, `Dependency review` status on every |
| 941 | pull request (OSV severity threshold, license deny list, summary comment). |
| 942 | - **Overview.** Workspace totals, opened/closed, a daily snapshot trend, |
| 943 | coverage, repositories most in need first. |
| 944 | - **Paid.** The Security and quality activation on private repositories; |
| 945 | free on public ones; the free core (secret scanning, push protection, |
| 946 | vulnerability alerts, security updates, dependency graph) free everywhere. |
| 947 | |
| 948 | Not built yet: |
| 949 | |
| 950 | - **The reviewer agent as an analysis source.** g1t's reviewer reads each |
| 951 | pull request's diff (`agent_review`), but its findings are review |
| 952 | comments, not SARIF. Next: have it emit SARIF for the security issues it |
| 953 | finds and upload them as the tool `g1t review`, so they become alerts and |
| 954 | count toward the Code scanning check. |
| 955 | - **Repository security advisories.** Private advisories, draft → |
| 956 | published, with affected versions (ranges per ecosystem), severity and a |
| 957 | CVSS vector, credits, and a private fork (a `g1t/advisory/GHSA-…` working |
| 958 | copy only the advisory's collaborators can see) for the fix, merged into |
| 959 | the default branch when the advisory publishes. Published advisories |
| 960 | should feed the OSV-shaped data other g1t repositories' vulnerability |
| 961 | alerts read. CVE requests are out of scope. Needs: an `advisories` table |
| 962 | per repository, a collaborator list per advisory, the private-fork |
| 963 | visibility rule in repos, and an Advisories page on the Security tab. |
| 964 | - **SARIF upload as a background job.** Uploads are read in the request |
| 965 | (10 MB encoded, 40 MB unzipped, 5,000 results); larger ones need a queue. |
| 966 | |
| 967 | ### Deployments |
| 968 | |
| 969 | - **A preview for every pull request**, at |
| 970 | `<pr>--<repo>--<owner>.g1t.page`, linked on the pull request and updated |
| 971 | on each push. `main` deploys to `<repo>--<owner>.g1t.page`, and a |
| 972 | repository can add its own domain. |
| 973 | - **On g1t.page, not g1t.sh,** so customer code never shares cookies or an |
| 974 | origin with the site people sign in to. |
| 975 | - **Built on Workers for Platforms.** Each deployment is a user Worker in a |
| 976 | dispatch namespace; one dispatch Worker on `*.g1t.page` routes to it. The |
| 977 | build runs in the same runners as Actions. Static sites and Workers apps |
| 978 | first; container apps and databases later. |
| 979 | - **Agents use the preview.** The reviewer agent opens the preview in a |
| 980 | browser, takes screenshots of what changed and attaches them to its |
| 981 | review, so an approver sees the result without reading the diff. |
| 982 | - **Environments.** Preview, production and their secrets; deploy history |
| 983 | and one-click rollback. |
| 984 | - **Scale to zero.** An idle branch costs neither g1t nor the customer |
| 985 | anything: a Worker runs, and is billed, only while it answers a request. |
| 986 | A preview is deleted when its pull request closes or merges, and after |
| 987 | a set number of idle days. Container apps, later, sleep when idle. |
| 988 | - **Billed to the customer, never free.** The user (2026-10-04): "we |
| 989 | should not be giving any of this available for free". Every deployment |
| 990 | is metered per workspace (requests, CPU time, deployed apps, stored |
| 991 | data), priced at Cloudflare's cost + 20% like agent usage, and drawn |
| 992 | from prepaid credit. `FREE_WHILE_BUILDING` and the free model allowance |
| 993 | do not cover deployments: a workspace without credit cannot deploy, and |
| 994 | turning deployments on says so first. |
| 995 | - **Turning them on is a paid plan, the way Cloudflare's is.** "Including |
| 996 | things like them even enabling the feature should have that pay like |
| 997 | Cloudflare does." Enabling deployments for a workspace starts a monthly |
| 998 | fee that includes an allowance of requests, CPU time and deployed apps; |
| 999 | usage past it is billed per unit, as Workers for Platforms bills g1t. |
| 1000 | The fee and allowance are the user's to set. |
| 1001 | - **Recommended, off in one click.** Because enabling costs money, it is |
| 1002 | never switched on without the workspace agreeing: new repositories |
| 1003 | recommend it prominently. A repository can turn it off, keep only production, or |
| 1004 | deploy somewhere else from its own workflows. Apps built for Cloudflare |
| 1005 | (Workers, static assets, D1, KV, R2) deploy without configuration. |
| 1006 | |
| 1007 | Later, toward GitLab's DevOps breadth: package and container registries, |
| 1008 | releases, container hosting. (Environments' protection rules for g1t |
| 1009 | Actions were built on 2026-10-08; see above.) |
| 1010 | |
| 1011 | ## Projects |
| 1012 | |
| 1013 | > **2026-10-04:** the user: "an extra dimension of Projects so it's not |
| 1014 | > just repositories … where a lot of things can live", "very Vercel |
| 1015 | > like", with dependencies across projects "the Platform Engineering / |
| 1016 | > Port route", and "the repository is *part* of a project: you could be |
| 1017 | > mirroring it from GitHub/GitLab/Bitbucket, or you could let us host it |
| 1018 | > for you", with room for Mercurial or anything else later. |
| 1019 | |
| 1020 | **A project is the thing you are building and running; a repository is |
| 1021 | where some of its code lives.** Everything that is about running software |
| 1022 | (deployments, environments, domains, secrets, dependencies, owners, |
| 1023 | health, upkeep) belongs to the project. What is about the code itself |
| 1024 | (branches, pull requests, review, merge rules) stays with the repository. |
| 1025 | That split is what lets the code live anywhere. |
| 1026 | |
| 1027 | ### The model |
| 1028 | |
| 1029 | | | What it is | Like | |
| 1030 | | --- | --- | --- | |
| 1031 | | **Workspace** | The company or team. Members, billing, plans, shared secrets. | Vercel team, GitLab group, GitHub org | |
| 1032 | | **Group** | An optional named set of projects, one level: "Payments", "Mobile". For browsing, ownership and shared settings. | GitLab subgroup, Backstage system, Port domain | |
| 1033 | | **Project** | One deployable thing: a site, an API, a worker, a library. Has exactly one **source**. | Vercel project, Port service, Backstage component | |
| 1034 | | **Source** | Where its code is: a repository and a **root directory** in it. | Vercel's connected repo + root directory | |
| 1035 | | **Dependency** | Project A uses project B: calls its API, consumes its package, reads its queue. | Port relations, Backstage `dependsOn` | |
| 1036 | |
| 1037 | - **One project, one source; one repository, any number of projects.** A |
| 1038 | project builds from exactly one place, which keeps it as simple as |
| 1039 | Vercel's. A monorepo is several projects on one repository, each with |
| 1040 | its own root directory (`apps/web`, `services/api`), and a push builds |
| 1041 | only the projects whose root it touched. The common case stays 1:1, and |
| 1042 | every existing repository gets a project of its own name when this |
| 1043 | ships, so nobody has to set anything up. |
| 1044 | - **Groups are for people; dependencies are for software.** Groups decide |
| 1045 | where a project shows up and who owns it. Dependencies decide what |
| 1046 | happens when one changes. Neither replaces the other, and a dependency |
| 1047 | can cross groups. |
| 1048 | |
| 1049 | ### Sources: where the code lives |
| 1050 | |
| 1051 | A source is an adapter behind one interface (`SourcePort`: clone URL, |
| 1052 | branches, commits, pushes as events, pull requests if it has them): |
| 1053 | |
| 1054 | | Source | Code lives | g1t gets pushes by | Pull requests | |
| 1055 | | --- | --- | --- | --- | |
| 1056 | | **Hosted on g1t** (today) | Artifacts | its own events | g1t's, with agents, the queue, review | |
| 1057 | | **Mirrored** from GitHub, GitLab or Bitbucket | Both; g1t keeps a copy | the provider's webhook, then fetch | The provider's, read into g1t; agents open theirs there | |
| 1058 | | **Connected, not copied** | The provider only | webhook | The provider's | |
| 1059 | | **Later:** Mercurial, Perforce, a tarball upload | Behind the same port | per adapter | per adapter | |
| 1060 | |
| 1061 | A mirrored or connected project still gets everything that is the |
| 1062 | project's: previews on its pull requests (a status and a comment on |
| 1063 | GitHub's), production on its default branch, secrets, dependencies, |
| 1064 | upkeep agents. That is the on-ramp: a team keeps GitHub and gets g1t's |
| 1065 | deployments and agents first, and moves the code later or never. |
| 1066 | Bring-your-own-git is also why the project, not the repository, holds the |
| 1067 | URL `g1t.sh/<workspace>/<project>`. |
| 1068 | |
| 1069 | ### What lives on a project |
| 1070 | |
| 1071 | | | Today it is on | Moves to the project | |
| 1072 | | --- | --- | --- | |
| 1073 | | Deployments: production, previews, build settings, root directory, framework | The repository | Yes | |
| 1074 | | Environments: production, preview, and custom ones (`staging`) with protection rules (required approvers, branch limits) | Nowhere yet | New, on the project | |
| 1075 | | Domains: `<project>--<workspace>.g1t.page`, and custom domains | The repository's name | Yes | |
| 1076 | | Secrets and variables | The repository | Yes. Workspace rows link to projects instead of repositories. A repository's workflows read the rows of its project (with several projects on one repository, the one marked as the repository's default). | |
| 1077 | | Dependencies | Nowhere | New | |
| 1078 | | Owners, on-call, links (docs, dashboards, runbooks) | Nowhere | New: the catalog's metadata | |
| 1079 | | Health: scorecards (has an owner, CI passes, dependencies current, no open security alerts, deploys within N days) | Nowhere | New | |
| 1080 | | Upkeep agents: dependency updates, security alerts | The plan | Scoped per project | |
| 1081 | | Logs and analytics of the running app | Nowhere | New: requests, errors and CPU per environment, from Workers analytics | |
| 1082 | | Branches, pull requests, review, merge rules, the queue, webhooks | The repository | Stay | |
| 1083 | |
| 1084 | ### Dependencies: why this gets powerful |
| 1085 | |
| 1086 | Declared in the UI, or in the source as `.g1t/project.yml` (which wins |
| 1087 | when present, as `catalog-info.yaml` does in Backstage): |
| 1088 | |
| 1089 | ```yaml |
| 1090 | name: web |
| 1091 | root: apps/web |
| 1092 | dependsOn: |
| 1093 | - project: api # calls its HTTP API |
| 1094 | as: API_URL # its URL, per environment, as a variable |
| 1095 | - project: ui-kit # consumes its package |
| 1096 | ``` |
| 1097 | |
| 1098 | What g1t does with them: |
| 1099 | |
| 1100 | 1. **Reference variables.** `API_URL` above resolves to `api`'s production |
| 1101 | URL in production and to the matching preview in a preview, the way |
| 1102 | Railway's `${{ api.URL }}` references work. No hard-coded URLs. |
| 1103 | 2. **Preview stacks.** A pull request on `api` gets its own preview, and |
| 1104 | **Preview with dependents** builds `web`'s preview pointed at it, so a |
| 1105 | reviewer clicks through the whole change across projects. A change that |
| 1106 | spans repositories (one issue, one fork per repository) gets one stack. |
| 1107 | 3. **Release order.** Production deploys go out in dependency order; a |
| 1108 | change set across projects lands through the queue together or not at |
| 1109 | all. |
| 1110 | 4. **Impact on every pull request.** "Changes `api`; `web` and `mobile` |
| 1111 | depend on it." Agents get the graph in their context: an agent |
| 1112 | changing an API opens follow-up issues on the projects that call it, |
| 1113 | and reviewers see what else could break. |
| 1114 | 5. **Upkeep across the graph.** A vulnerable package in `ui-kit` opens |
| 1115 | issues, assigned to agents, on every project that consumes it. |
| 1116 | 6. **Scorecards turn into work.** A project failing a scorecard check |
| 1117 | ("no owner", "dependencies 90 days old") gets an issue an agent can fix. |
| 1118 | That is the Port idea with the work done for you. |
| 1119 | 7. **The map.** A workspace's projects as a graph, coloured by health and |
| 1120 | by what is deploying now. |
| 1121 | |
| 1122 | ### Pages |
| 1123 | |
| 1124 | - `g1t.sh/<workspace>`: projects first (grouped, with health and |
| 1125 | production status), then repositories. |
| 1126 | - `g1t.sh/<workspace>/<project>`: overview (production, latest previews, |
| 1127 | health, owners, dependencies both ways), **Deployments**, |
| 1128 | **Environments**, **Secrets and variables**, **Logs**, **Settings** |
| 1129 | (source, root directory, build, domains, groups, owners). |
| 1130 | - A hosted repository keeps its code pages; from a project they are its |
| 1131 | **Code** tab. A repository page lists the projects built from it. |
| 1132 | |
| 1133 | ### Services |
| 1134 | |
| 1135 | - `services/projects` (new): projects, groups, sources, dependencies, |
| 1136 | owners, scorecards. Events `project.created`, `project.updated`, |
| 1137 | `dependency.changed`. |
| 1138 | - `services/deployments`: keyed by project instead of repository. |
| 1139 | - Secrets and variables: the scope becomes workspace → project. |
| 1140 | - Sources: the hosted adapter wraps `services/repos`; a mirror adapter |
| 1141 | per provider in `services/integrations`, which already holds those |
| 1142 | connections. |
| 1143 | |
| 1144 | ### Build order |
| 1145 | |
| 1146 | 1. **Projects as the home of deployments and secrets**, 1:1 with every |
| 1147 | existing repository: the service, the pages, deployments and secrets |
| 1148 | moved to the project, `<project>--<workspace>.g1t.page`. |
| 1149 | 2. **Dependencies:** declared in the UI and `.g1t/project.yml`, reference |
| 1150 | variables, impact on pull requests and in agents' context, the map. |
| 1151 | 3. **Preview stacks** and cross-project change sets. |
| 1152 | 4. **Monorepos:** several projects on one repository, each with a root |
| 1153 | directory, building only what a push touched. |
| 1154 | 5. **Mirrored sources:** GitHub first, then GitLab and Bitbucket. |
| 1155 | 6. **Groups, owners, scorecards** feeding the upkeep agents. |
| 1156 | 7. **Environments** with protection rules; custom domains; logs. |
| 1157 | |
| 1158 | **Step 1 shipped 2026-10-04:** `services/projects`; every repository a |
| 1159 | project of its own name; the site projects-first (workspace page of |
| 1160 | project cards, the project overview at `g1t.sh/<workspace>/<project>`, code |
| 1161 | under `/code`, the sidebar and the New project flow); deployments keyed by |
| 1162 | project and branch at `<project>-<workspace>.g1t.page` and |
| 1163 | `<project>-git-<branch>-<workspace>.g1t.page`; secrets and variables owned |
| 1164 | by the project. |
| 1165 | |
| 1166 | **Step 5, GitHub, built 2026-10-05:** one GitHub App (`g1t-sh`) for both |
| 1167 | sign-in and repository access. Sign-in is its user authorization with PKCE |
| 1168 | (identity, `src/github.rs`): accounts known by GitHub's numeric id, a |
| 1169 | matching verified email never linked without signing in to the account, |
| 1170 | new accounts behind the invite check. Repositories come through its |
| 1171 | installations (integrations, `src/github.rs`), copied with every branch and |
| 1172 | tag by the repos service (`src/mirror.rs`) as **import**, **mirror** (g1t |
| 1173 | follows GitHub on its push webhook) or **move to g1t** (GitHub follows g1t |
| 1174 | on `git.push`). A mirror is a hosted repository that keeps a full copy, so |
| 1175 | its project stays `hosted` and deploys like any other; the tie lives in |
| 1176 | integrations' `github_repos`. Not yet: previews and statuses on GitHub's own |
| 1177 | pull requests, comments and pull requests copied, GitLab and Bitbucket. |
| 1178 | |
| 1179 | ### People and search |
| 1180 | |
| 1181 | > **2026-10-04:** "pull up user profiles, using a /u/username prefix kinda |
| 1182 | > like DockerHub … search for users if you search that explicitly, how |
| 1183 | > GitHub has the aside for searching against filters … a significantly |
| 1184 | > stronger implementation." |
| 1185 | |
| 1186 | - **Profiles at `g1t.sh/u/<username>`**, apart from workspaces at |
| 1187 | `g1t.sh/<workspace>`: who they are, their workspaces, recent work, |
| 1188 | agents' sessions they steered. |
| 1189 | - **Search with a filter sidebar:** Projects, Code, Issues, Pull requests, |
| 1190 | Users, Workspaces, each with its count; filters by workspace, language, |
| 1191 | state, author, agent, label, date; qualifiers in the query |
| 1192 | (`user:`, `is:open`, `agent:g1t`) as on GitHub. Typing `u/name` |
| 1193 | searches people directly, as Docker Hub does. |
| 1194 | |
| 1195 | 1 and 2 serve the competition directly (multi-agent coordination across |
| 1196 | projects is 25% of the score); 3 is the demo's best moment if time allows. |
| 1197 | |
| 1198 | ## Billing model |
| 1199 | |
| 1200 | > **2026-10-04:** "Some things just require you to have a card on file … |
| 1201 | > some things will be something you give us an initial amount of money |
| 1202 | > per month just to activate, tons of things additionally will be usage |
| 1203 | > based, some things will just be usage based only … at minimum a |
| 1204 | > breakeven with Cloudflare costs, or in some cases a value add." Stripe |
| 1205 | > moves to Flagon, Inc. (g1t.sh is its product). Proposed below; the |
| 1206 | > prices are the user's to confirm. |
| 1207 | |
| 1208 | ### Four kinds of charge |
| 1209 | |
| 1210 | Every feature is exactly one of these, and the Billing page says which: |
| 1211 | |
| 1212 | | Kind | What the workspace does | Example | |
| 1213 | | --- | --- | --- | |
| 1214 | | **Free** | Nothing | Hosting code, issues, pull requests, review, the merge queue, bringing your own agent over MCP | |
| 1215 | | **Card on file** | Adds a card; pays only for what it uses | Previews, g1t's agents, workflow minutes | |
| 1216 | | **Activation** | Turns a feature on for a monthly fee that includes an allowance; usage past it is metered | Production deployments, Security and quality | |
| 1217 | | **Usage only** | Nothing up front; every unit is metered | Model tokens, build minutes, storage past the free amount | |
| 1218 | |
| 1219 | A card is needed before anything that can cost money starts. Nothing is |
| 1220 | ever switched on without the workspace choosing it. |
| 1221 | |
| 1222 | ### Postpaid, with spend limits |
| 1223 | |
| 1224 | - **One Stripe customer and one subscription per workspace**, on Flagon, |
| 1225 | Inc.'s account. Activations are licensed line items; every usage |
| 1226 | dimension is a metered price backed by a Stripe Meter. Stripe invoices |
| 1227 | monthly in arrears and charges the card on file; failed payments go |
| 1228 | through Stripe's retries and emails, and g1t hears of them by webhook. |
| 1229 | - **Spend limits instead of prepaid credit.** A workspace sets a monthly |
| 1230 | limit overall and per feature (Vercel's spend management). g1t counts |
| 1231 | usage as it happens and stops starting new paid work at the limit, |
| 1232 | with a warning at 50%, 80% and 100%. Prepaid top-ups go away; promotions |
| 1233 | (the free model allowance) become Stripe credit on the customer. |
| 1234 | - **Usage reaches Stripe from billing alone.** Every service reports |
| 1235 | usage to the billing service as it happens (it already records agent |
| 1236 | runs and builds); billing batches them into Stripe meter events every |
| 1237 | few minutes, idempotently by g1t's own ids, and keeps the ledger g1t's |
| 1238 | pages show. Nothing else talks to Stripe. |
| 1239 | |
| 1240 | ### Scope: workspace, then projects |
| 1241 | |
| 1242 | - A feature is turned on for the **workspace** (by an owner, with the |
| 1243 | activation if it has one), then allowed for **all projects** or |
| 1244 | **selected projects**. |
| 1245 | - Every **project** can opt out on its own page. A project with nothing |
| 1246 | to deploy (no Workers config, no build script, no `index.html`) is |
| 1247 | detected, says so on its Deployments page, and never builds or costs |
| 1248 | anything. |
| 1249 | - Agents and workflows are allowed per project the same way, so a |
| 1250 | workspace can keep spend to the projects that matter. |
| 1251 | |
| 1252 | ### Prices: what it costs us, passed through |
| 1253 | |
| 1254 | > **2026-10-04, decided:** postpaid with spend limits, as Vercel and |
| 1255 | > Cloudflare do; no per-seat price, ever ("fuck per-seat pricing"). |
| 1256 | > "If they're barely using them great, but if they're using the shit out |
| 1257 | > of them that will cost me a ton, so that cost needs to move onto them." |
| 1258 | |
| 1259 | **Every Cloudflare cost a workspace causes is metered to it.** Light use |
| 1260 | fits in a small free allowance; past it, each unit is charged at |
| 1261 | Cloudflare's price times a margin of at least 1.5, which pays for Stripe |
| 1262 | (about 3%), shared overhead (the site, the API, D1) and g1t itself. |
| 1263 | |
| 1264 | Cloudflare's prices (October 2026), and the cost per unit g1t meters: |
| 1265 | |
| 1266 | | What g1t meters | Cloudflare's price | Cost to g1t per unit | |
| 1267 | | --- | --- | --- | |
| 1268 | | **Sandbox minute** (agents, checks, merge queue, workflow jobs, deploy builds), standard-1: ½ vCPU, 4 GiB, 8 GB | CPU $0.00002 / vCPU-s while busy; memory $0.0000025 / GiB-s and disk $0.00000007 / GB-s while running | ≤ $0.0012 / minute (CPU counted as busy throughout, since g1t cannot see it per sandbox) | |
| 1269 | | **App request** (deployments) | Workers for Platforms: $0.30 / million past 20M | $0.30 / million | |
| 1270 | | **App CPU** | $0.02 / million CPU-ms past 60M | $0.02 / million ms | |
| 1271 | | **App** (a deployed script) | $0.02 / script-month past 1,000 | $0.02 / app-month | |
| 1272 | | **Storage** (repositories, artifacts, caches) | Artifacts $0.50 / GB-month (billing starts 2026-10-14); KV $0.50 / GB-month | $0.50 / GB-month | |
| 1273 | | **Git operation** (clone, fetch, push) | Artifacts $0.15 / 1,000 past 10,000 | $0.15 / 1,000 | |
| 1274 | | **Model tokens** | The provider's price | As charged | |
| 1275 | | Container egress, emails, the site's own requests | Small and shared | In the margin | |
| 1276 | |
| 1277 | > **2026-10-06, decided:** no per-feature quotas on the plan. "A paying |
| 1278 | > user should be able to push past the Git operations number, they're |
| 1279 | > just paying usage on it." One plan, $20 a month per workspace with $10 |
| 1280 | > of usage included; every meter is charged from the first unit at cost + |
| 1281 | > 20% (builds, app requests and CPU, custom domains), drawn from the $10 |
| 1282 | > first, then up to the spend limit, which is the only thing that stops a |
| 1283 | > paying workspace (with abuse protection). Projects, previews and apps |
| 1284 | > are not metered (Workers for Platforms' script pool makes them ~free). |
| 1285 | > The forge's free amounts are the same for everyone: 1 GB private storage |
| 1286 | > and 50,000 git operations a month; past them the plan pays and a free |
| 1287 | > workspace is held (pushes stop, git slowed). The table below is the |
| 1288 | > earlier proposal; billing's price book and g1t.sh/pricing are current. |
| 1289 | |
| 1290 | What a workspace pays: |
| 1291 | |
| 1292 | | Meter | Free each month | Then | Margin | For comparison | |
| 1293 | | --- | --- | --- | --- | --- | |
| 1294 | | Sandbox minutes | None (2026-10-05: charged from the first second) | Cost + 20%, by the second | 1.2× | GitHub Actions $0.008 / minute (Linux 2-core); Vercel builds $0.0035 / CPU-minute | |
| 1295 | | App requests | 1 million with Deployments | $0.50 / million | 1.7× | Vercel $0.60 / million invocations | |
| 1296 | | App CPU | 3 million ms with Deployments | $0.04 / million ms | 2× | Vercel active CPU about $0.036 / million ms | |
| 1297 | | Apps | 10 with Deployments | $0.05 / app-month | 2.5× | | |
| 1298 | | Storage | 1 GB | $1.00 / GB-month | 2× | GitHub LFS $0.07 / GB, but repositories are free there | |
| 1299 | | Git operations | 10,000 | $0.30 / 1,000 | 2× | | |
| 1300 | | g1t's models | | Cost + 20% | 1.2× | The provider's own price | |
| 1301 | | Your own model provider | | Only its sandbox minutes (the $0.10 run fee was dropped 2026-10-05) | | | |
| 1302 | | **Deployments** activation | | $5 / month, with the allowances above | covers Workers for Platforms' $25 / month across workspaces | Vercel Pro $20 per seat | |
| 1303 | | **Security and quality** activation (built 2026-10-07: price book meter `security_activation`) | | $10 / month; fixes as agent usage | | GitHub Advanced Security $49 per committer | |
| 1304 | |
| 1305 | A workspace that uses g1t lightly (a few agent runs, a small site) |
| 1306 | pays nothing or its activation; a workspace running agents all day pays |
| 1307 | for the sandboxes and models those agents use, with g1t's margin on |
| 1308 | each. Nothing in a workspace's bill is subsidised by another's. |
| 1309 | |
| 1310 | ### Build order |
| 1311 | |
| 1312 | 1. Stripe customer per workspace and card on file (Checkout in setup |
| 1313 | mode), webhooks (invoice paid and failed, subscription changes, |
| 1314 | payment method changes), the Billing page rebuilt around the four |
| 1315 | kinds. |
| 1316 | 2. One subscription per workspace with activations as items; Deployments |
| 1317 | moves onto it. |
| 1318 | 3. Meters for each usage dimension above, fed from billing's ledger: |
| 1319 | every sandbox reports how long it ran when it stops (agents, checks, |
| 1320 | the queue, workflow jobs and deploy builds alike); deployments report |
| 1321 | requests, CPU and apps; repos report storage and git operations. Spend |
| 1322 | limits and their warnings; prepaid credit retired. |
| 1323 | 4. Per-workspace allow-lists of projects for each feature, and per-project |
| 1324 | opt-out; "nothing to deploy" detection. |
| 1325 | 5. Turn off FREE_WHILE_BUILDING when the user says so. **Done 2026-10-05.** |
| 1326 | |
| 1327 | Shipped by 2026-10-05: sandbox seconds for every sandbox; the price book |
| 1328 | and its keeper (runs settled to AI Gateway's price every 15 minutes; |
| 1329 | Container and Workers costs checked against Cloudflare's billable usage |
| 1330 | and container analytics daily, with a public change log on |
| 1331 | g1t.sh/pricing); usage limits by trust with automatic payment near the |
| 1332 | limit; app traffic counted toward limits as it happens; billing accounts, |
| 1333 | terms and enterprises; free mode off, syntaqx comped. |
| 1334 | |
| 1335 | Still to build, in order: Stripe card-on-file without a payment (setup |
| 1336 | mode) and webhooks; month-end invoices for postpaid usage (and one |
| 1337 | invoice per enterprise); the subscription with activations as items; |
| 1338 | storage and git-operation meters; limit warnings by email at 50/80/100%; |
| 1339 | self-serve enterprise management for enterprise owners. |
| 1340 | |
| 1341 | ### Accounts, terms and enterprises |
| 1342 | |
| 1343 | Every workspace is paid for by a billing account: its own (`ws_<slug>`) |
| 1344 | or an enterprise's (`ent_…`), which pays for several workspaces with one |
| 1345 | limit, one set of terms and, once invoices exist, one bill, as GitHub |
| 1346 | Enterprise does. Terms are standard, comped (nothing charged, usage still |
| 1347 | recorded at cost, paid features on) or custom (a discount, its own |
| 1348 | ceiling, an end date). g1t staff manage them in **sudo.g1t.sh**, a |
| 1349 | separate Worker behind Cloudflare Access that also verifies the Access |
| 1350 | token itself and allows only listed staff emails; every change is kept |
| 1351 | with who made it and why. |
| 1352 | |
| 1353 | ### Limits: stop non-payers, never payers |
| 1354 | |
| 1355 | The limit is on usage not yet paid for, counted at cost to g1t or charge, |
| 1356 | whichever is more: $3 before any live payment, then twice what has been |
| 1357 | paid ($25 to $1,000), or what staff set. A workspace with a card on file |
| 1358 | is charged automatically near its limit, which both pays what it owes and |
| 1359 | raises the limit, so paying users are never stopped. A declined card |
| 1360 | stops work until paid. The owner's own spend limit always means stop. |
| 1361 | Test-mode payments never lower exposure or raise trust. |
| 1362 | |
| 1363 | ### Tax, card fees and free workspaces (built 2026-10-08) |
| 1364 | |
| 1365 | > **2026-10-08, decided:** Stripe Tax everywhere ("so I don't fuck up on |
| 1366 | > taxes"); Stripe's card fee passed to the customer with the 20% markup |
| 1367 | > kept; one free workspace per person; no invites on free workspaces. |
| 1368 | |
| 1369 | - **Stripe Tax on every payment.** `automatic_tax` on every Checkout page |
| 1370 | (plan, Security and quality, prepaying, AI credit), every subscription |
| 1371 | and every invoice g1t makes (month close, threshold, enterprise), and a |
| 1372 | tax calculation and transaction for auto-reload's off-session charge. |
| 1373 | Tax code `txcd_10103001` (SaaS, business use), every price |
| 1374 | `tax_behavior=exclusive`. Checkout always collects the billing address |
| 1375 | and tax ID and saves them on the customer. Prices on g1t are shown |
| 1376 | excluding tax. Tax is never revenue: balances and plan payments are |
| 1377 | credited without it, it is kept in `tax_and_fees`, shown as its own |
| 1378 | statement line, and as **Tax collected** on sudo's Costs. Without an |
| 1379 | address g1t does not charge: the owners are asked for one. |
| 1380 | - **The card fee** (2.9% + $0.30, grossed up) is its own line on every |
| 1381 | card payment, the plan's and Security's as a monthly item; never on a |
| 1382 | bank transfer or an enterprise's invoice. On by default |
| 1383 | (`cost_settings.card_fee`). Not revenue either. Meters stay at cost + |
| 1384 | 20%; models at the provider's price plus the agent rate. |
| 1385 | - **One free workspace per person.** Identity asks billing |
| 1386 | (`free_workspaces`) before creating one; a second is refused with the |
| 1387 | way forward. Those who own several from before keep them. |
| 1388 | - **A free workspace adds no one**: no members, invites or outside |
| 1389 | collaborators until it starts the plan; its members stay; @g1t never |
| 1390 | counts. Enforced in identity for every path (site, API, MCP). |
| 1391 | - Details: docs/BILLING_OPERATIONS.md, *Tax and the card fee*. |
| 1392 | |
| 1393 | ### Promo codes (planned) |
| 1394 | |
| 1395 | Staff credits (promotional, goodwill, refund; `services/billing/src/grants.rs`, |
| 1396 | docs/BILLING_OPERATIONS.md) are given one workspace at a time. Promo codes |
| 1397 | give promotional credit in bulk, on redemption, through the same grants: |
| 1398 | |
| 1399 | - **Codes.** sudo → Credits & refunds → **New code**: the code (or one |
| 1400 | made up), the credit ($ amount), max redemptions, when the code stops |
| 1401 | working, how long each redeemed credit lasts (an expiry, as any grant), |
| 1402 | and a note. Table `promo_codes` (code, amount, max, redeemed, ends_at, |
| 1403 | credit_days, note, created_by, disabled_at) and `promo_redemptions` |
| 1404 | (code, workspace, grant id, by, at), unique on (code, workspace). |
| 1405 | - **Redeeming.** An owner types it on the workspace's Billing page |
| 1406 | (`redeem_code`, owners only). One D1 batch checks the code is open, under |
| 1407 | its max and not redeemed by the workspace, counts the redemption and |
| 1408 | makes the grant (`grant_credit`, kind promotional, the code as its note), |
| 1409 | so two redemptions at once never pass the max. Wrong or used-up codes say |
| 1410 | so without telling which codes exist; redemptions are rate-limited per |
| 1411 | owner. |
| 1412 | - **Seeing them.** Each code's redemptions, credit given and spent come |
| 1413 | from the grants it made, so margin needs nothing new: spent promo credit |
| 1414 | is already given away, by kind. |
| 1415 | - **Not yet built** because it adds an owner-facing form, abuse limits and |
| 1416 | a second sudo form; giving credit by workspace covers launch. |
| 1417 | |
| 1418 | ## Agents and models |
| 1419 | |
| 1420 | ### Defining an agent |
| 1421 | |
| 1422 | An agent is a file (`.g1t/agents/<name>.md`, or in the workspace library): |
| 1423 | instructions, the harness and model to run, the tools and MCP servers it may |
| 1424 | use, its sandbox image, permissions and budget. Agents take roles: planner, |
| 1425 | implementer, reviewer, conflict resolver, documenter, memory consolidator. |
| 1426 | Each role has a default that a repo can replace. |
| 1427 | |
| 1428 | ### Where it runs, and on whose model |
| 1429 | |
| 1430 | | Option | How it works | Fits | |
| 1431 | | --- | --- | --- | |
| 1432 | | Hosted, g1t's model | g1t runs the sandbox and bills usage | Getting started; no keys to manage | |
| 1433 | | Hosted, your API key | Same sandbox, your Anthropic, OpenAI or Google key | Teams with existing contracts | |
| 1434 | | Hosted, your endpoint | Any OpenAI-compatible URL: Bedrock, Vertex, Azure, a self-hosted model | Private or fine-tuned models | |
| 1435 | | Your runner | A g1t runner daemon on your own machines picks up pull requests | Code or models that may not leave your network | |
| 1436 | | Your own session | Local Claude Code, Cursor or any MCP client joins through `mcp.g1t.sh` | Individuals; subscription plans | |
| 1437 | |
| 1438 | Decisions behind this: |
| 1439 | |
| 1440 | - **g1t does not build its own agent loop.** It runs existing harnesses |
| 1441 | (Claude Code first, through its headless mode) behind a small runner |
| 1442 | contract: a container image, an entry command, and session events reported |
| 1443 | through the CLI. Other harnesses plug in by meeting the contract. |
| 1444 | - **All hosted model traffic goes through Cloudflare AI Gateway.** That gives |
| 1445 | one place for spend tracking, budgets, rate limits, fallback and logs, |
| 1446 | whichever provider or endpoint is behind it. |
| 1447 | - **Nobody has to pick a model.** A person assigns work to `g1t`, as |
| 1448 | they would assign an issue to a colleague, and **Auto** routes each job |
| 1449 | to the cheapest model that can do it (see |
| 1450 | [Routing for cost](#routing-for-cost) below). A workspace can pin a tier |
| 1451 | per kind of work instead. Each request is tagged at the gateway with the |
| 1452 | kind of work, the tier, the repository and the pull request, and each |
| 1453 | run says which model ran and why. The gateway's own dynamic routes |
| 1454 | cannot make the choice yet: they work only on its OpenAI-compatible |
| 1455 | endpoint, and the harness speaks Anthropic's. |
| 1456 | - **Subscriptions stay local.** A Claude subscription cannot be used by a |
| 1457 | hosted sandbox; it needs an API key. People on subscriptions use their own |
| 1458 | Claude Code session, which is a full participant. |
| 1459 | - **The workspace pays.** A workspace buys AI credit by card and each |
| 1460 | agent run deducts the model at the provider's price plus the agent rate |
| 1461 | per million (weighted) tokens; on its own model key, only the agent rate, |
| 1462 | counted from the model proxy and the sandbox's own report. The billing service asks |
| 1463 | nothing of the others: the runner asks it before starting a sandbox and |
| 1464 | is refused when there is no credit, and the sandbox reports what its run |
| 1465 | cost with a token only it holds. Where no card processor is configured |
| 1466 | nothing is charged and agents stay limited to listed accounts. |
| 1467 | - **Keys are secrets.** Stored in Cloudflare Secrets Store, injected into the |
| 1468 | sandbox for one pull request, never shown again. |
| 1469 | |
| 1470 | ### Seeing a pull request through |
| 1471 | |
| 1472 | Assigning an issue is the only thing a person does until there is something |
| 1473 | to merge. A pull request made by g1t goes through checks, a review |
| 1474 | by another agent, revision when either finds something, and catching up |
| 1475 | when `main` moves, without anyone pressing a button. It ends as ready to |
| 1476 | merge, or as "needs you" with the reason: the checks still fail after two |
| 1477 | revisions, a review could not be written, or a conflict could not be |
| 1478 | resolved. |
| 1479 | |
| 1480 | The work service decides the next step from the pull request's state and |
| 1481 | claims it in one statement, so a step is taken once. The runner asks on |
| 1482 | every event that could change the answer (ready, pushed, checks finished, |
| 1483 | review finished, `main` moved), and on a five-minute sweep for anything |
| 1484 | missed, and carries the step out in a sandbox. |
| 1485 | |
| 1486 | A pull request does not have to be up to date with `main` to merge, |
| 1487 | unless the repository's settings require it, as on GitHub. Merging one that |
| 1488 | is behind brings it up to date first (a clean merge needs no model; an |
| 1489 | agent resolves a conflict) and lands it when that push arrives. With the |
| 1490 | requirement on, catching up is a step of its own and the checks run again |
| 1491 | on the result. |
| 1492 | |
| 1493 | Each repository sets its own rules, on one settings page: whether its |
| 1494 | default branch takes pushes at all, how many approvals a merge needs and |
| 1495 | whether an agent's counts, whether failed checks can be overridden, whether |
| 1496 | a second agent reviews, and how often an agent is sent back before a person |
| 1497 | is asked. A pull request g1t opens follows the same rules as anyone's. |
| 1498 | Pushes to a protected branch are refused in the git front end, with the |
| 1499 | reason shown by git beside the branch. |
| 1500 | |
| 1501 | Merging is a person's decision unless the repository says otherwise. With |
| 1502 | "merge automatically when ready" turned on in its settings, a ready pull |
| 1503 | request lands by itself, attributed to `g1t`. That is the whole path from |
| 1504 | an assigned issue to a commit on `main` with nobody in between. Required |
| 1505 | human approval per path, and risk tiers, are still to come. |
| 1506 | |
| 1507 | ### Routing for cost |
| 1508 | |
| 1509 | *Built (runner `route` in `services/runner/src/model-env.ts`).* The goal |
| 1510 | is cost per merged change, not cost per request: a cheap attempt that |
| 1511 | fails and is retried on the same model costs more than one that finishes. |
| 1512 | |
| 1513 | - **Tiers and catalogue.** `small` (Claude Haiku 5.5 since 2026-10-08, |
| 1514 | $0.10/$0.50 per million input/output up to 100k-token prompts, five |
| 1515 | times that above; it was Haiku 4.5 at $1/$5), `large` (Claude Sonnet 5.5, $2/$10) and `frontier` |
| 1516 | (Claude Opus 5.5, $4/$20). Models, names and list prices are data, |
| 1517 | never code: since 2026-10-08 billing's model catalogue |
| 1518 | (`gateway_models`, one row per model g1t can use) and staff's defaults |
| 1519 | in sudo, **Agents & models** (`model_defaults`: each tier's model, the |
| 1520 | harness's background model, the AI Gateway's first Claude, each job's |
| 1521 | starting tier and effort), read by the runner once a minute over |
| 1522 | `AGENT_ROUTING`, which is only the fallback when billing cannot be read. |
| 1523 | Catalogue prices are for estimates only; runs are charged what AI |
| 1524 | Gateway priced them at. |
| 1525 | - **Keeping up with new models (built 2026-10-08).** The models service |
| 1526 | lists Anthropic's models (through the AI Gateway) and Workers AI's daily |
| 1527 | and on demand; a new id lands in the catalogue as `new`, priced from a |
| 1528 | maintained table of Anthropic's list prices or Workers AI's listing, or |
| 1529 | unpriced, and staff are emailed. Nothing routes to it, offers it or |
| 1530 | charges for it until staff approve it with its prices. A model a provider |
| 1531 | stops listing is `deprecated`; routing never sends work to a deprecated |
| 1532 | or retired model, falling back to the next model of the tier and saying |
| 1533 | so on the run. Customers keep Auto: the catalogue is staff's. See |
| 1534 | [BILLING_OPERATIONS.md](BILLING_OPERATIONS.md#the-model-catalogue). |
| 1535 | - **Starting tier by job.** Catch-up, answering a question, and reviews of |
| 1536 | at most 10 files and 200 lines touching no sensitive path: small. |
| 1537 | Plans: small at high effort (Haiku 5.5 takes an effort level). |
| 1538 | Changes, revisions and other reviews: large. Reviews over 60 files |
| 1539 | or 3,000 lines: frontier. Labels: `architecture` frontier, `security` off |
| 1540 | small, `docs`/`documentation`/`typo` let changes and answers start small. |
| 1541 | - **Escalation.** A failed (or guardrail-stopped) attempt at the same work |
| 1542 | goes one tier up; two in a row, frontier; a revision counts its rounds; |
| 1543 | a change left at low confidence sends the next attempt up. |
| 1544 | - **Learning, per repository.** From the last 20 runs of the same kind: |
| 1545 | one tier down when the cheaper tier finished at least 90% of at least 5 |
| 1546 | (never for sensitive or labelled work, never on a retry); one tier up |
| 1547 | when this tier failed at least half of at least 5. No new tables: it |
| 1548 | reads work's `agent_runs` (model, status, confidence). |
| 1549 | - **Explained.** Every run's first step and session note is one line: |
| 1550 | *Used a fast model (Claude Haiku 5.5): small change, 3 files and 80 |
| 1551 | lines.* Effort per kind of job (`effort` in `AGENT_ROUTING`: plan high, |
| 1552 | answer medium, update low) is sent as `CLAUDE_CODE_EFFORT_LEVEL` on |
| 1553 | g1t's tiers (never on a model the catalogue says takes none) and named |
| 1554 | in that line, with the catalogue's name for the model. |
| 1555 | - **Chosen instead.** `model_routes` rows to g1t's models name `small`, |
| 1556 | `large` or `frontier`, or nothing for Auto (Integrations → Models). |
| 1557 | A workspace's own Anthropic key with no model named is routed by Auto |
| 1558 | too. |
| 1559 | - **Measured.** `scripts/ops/routing-savings.mjs` replays tasks through |
| 1560 | the router offline, priced from the catalogue, against routing before |
| 1561 | Auto and against the frontier model for everything, net of failed |
| 1562 | attempts, with cost per merged change; `--live` reads billing's runs and |
| 1563 | counted tokens. On the bundled sample (13 tasks, assumed failures): Auto |
| 1564 | costs 7% less than the frontier model for everything and about 7% more |
| 1565 | per run than routing before it, but half as much per merged change, |
| 1566 | because it finishes the hard tasks the old routing gave up on. At |
| 1567 | current prices Opus 5.5 and Sonnet 5.5 cost the same per cache read, and |
| 1568 | cache reads are most of an agent run's tokens, so moving off the |
| 1569 | frontier model saves less than its list price suggests; the fast tier |
| 1570 | and fewer failed attempts are where the money is. Run `--live` monthly |
| 1571 | and after any routing change. |
| 1572 | - **A cheaper route for the simplest jobs (designed, off).** A fourth tier |
| 1573 | on Workers AI through AI Gateway (an open model, billed on Cloudflare's |
| 1574 | invoice) for classification-sized jobs: commit messages, triage, |
| 1575 | summaries. Behind the same router as a tier with its own catalogue entry |
| 1576 | and `tasks` rules, off by default. It needs the proxy to translate the |
| 1577 | harness's Anthropic requests to the gateway's OpenAI-compatible |
| 1578 | endpoint (it already does for workspaces' own OpenAI-shaped providers) |
| 1579 | and a quality bar from the savings harness before any job moves to it. |
| 1580 | |
| 1581 | ### Choosing the right agent automatically |
| 1582 | |
| 1583 | Because several agents can work on the same issue, every issue with more |
| 1584 | than one pull request is an evaluation on real work. g1t records, per repo and per kind of issue, each |
| 1585 | agent's win rate, cost and time. That produces a leaderboard, and a routing |
| 1586 | policy: send each new issue to the agent that wins that kind most often, |
| 1587 | start with the cheapest that is good enough, and escalate to a stronger one |
| 1588 | when checks fail. |
| 1589 | |
| 1590 | ## Talking: the inbox and channels |
| 1591 | |
| 1592 | Not a discussions forum. People and agents need one place to talk in real |
| 1593 | time, and an app that feels like one on desktop and phone. |
| 1594 | |
| 1595 | **The inbox comes first.** Everything that needs a person or that they |
| 1596 | follow, from people and agents: review requests, agent questions and |
| 1597 | handoffs, failures, mentions, deploys. Read and unread, saved, done, |
| 1598 | snoozed; ranked so what an agent is blocked on comes first; email digests |
| 1599 | and push. It is the delivery layer chat needs too (who is told what, read |
| 1600 | state, push), so building it first makes channels cheap. |
| 1601 | |
| 1602 | *Built:* the events service keeps it (`services/events/src/inbox.rs` and |
| 1603 | `subscriptions.rs`, migrations `0005_inbox` and `0006_inbox_threads` on the |
| 1604 | `g1t-events` database), writing items as events arrive from the bus; work's |
| 1605 | `inbox_subject` says what each event names. Each person has one **thread** |
| 1606 | per issue, pull request, workflow on a branch or deployment: new activity |
| 1607 | brings it back unread with a count and its last 10 activities, and while it |
| 1608 | is unread its most urgent severity is kept. Each item has a **reason** |
| 1609 | (`agent`, `review_requested`, `assign`, `mention`, `ci_activity`, |
| 1610 | `security_alert`, `state_change`, `author`, `comment`, `manual`, |
| 1611 | `subscribed`). Who is told: `agent.asked` and `pull.stalled` (needs you, |
| 1612 | closed again by `pull.resumed` and the like), `pull.review_requested` |
| 1613 | (needs you, closed by `pull.review_request_removed`), |
| 1614 | `issue.assigned`/`pull.assigned`, failed checks and workflows, |
| 1615 | `deployment.failed` and a recovering `deployment.succeeded`, g1t's reviews |
| 1616 | and finished changes, closes, reopens and merges to everyone subscribed, |
| 1617 | and comments to the people mentioned and everyone subscribed. Never the |
| 1618 | actor, never g1t. **Subscriptions**: authors, assignees and reviewers are |
| 1619 | subscribed without a row; commenting or being mentioned subscribes; anyone |
| 1620 | can subscribe, unsubscribe (still told of what is asked of them) or ignore. |
| 1621 | **Watching** a repository: participating (the default), all, ignore, or |
| 1622 | custom (issues, pulls, deployments, security); whoever creates a repository |
| 1623 | watches it at their default, all activity unless they change it. |
| 1624 | **Settings**: which reasons are also emailed (agent, review_requested and |
| 1625 | mention by default) and the default watch for new repositories; email goes |
| 1626 | through identity's `notify_by_email`, to a confirmed address only while the |
| 1627 | person can still read the repository. **REST and MCP**: 14 operations under |
| 1628 | `/notifications`, `/repos/:owner/:name/subscription` and |
| 1629 | `/user/subscriptions` (scopes `notifications:read` and |
| 1630 | `notifications:write`, in the Agent preset), and the `notifications` MCP |
| 1631 | tool; never usable by g1t's own tokens. On the site: a bell in the top bar |
| 1632 | opening a sheet with tabs (All, Needs you, Errors, Success, Info), Done, |
| 1633 | Save, Snooze and Mark all read; `/inbox` with Saved, Done and a reason |
| 1634 | filter; reasons and update counts on each card; a Notifications box on |
| 1635 | issue and pull request pages; a Watch menu in the repository header; |
| 1636 | Settings → Notifications; a Needs you card on mission control. Agent sits |
| 1637 | beside the bell, disabled. Still to come: security alerts (the security |
| 1638 | service publishes no event yet), email digests and push, Agent, and |
| 1639 | channels. |
| 1640 | |
| 1641 | **Channels** (working name): workspace channels, direct messages and |
| 1642 | threads, live. |
| 1643 | |
| 1644 | - Each channel is a Durable Object holding its WebSocket connections with |
| 1645 | hibernation, so idle channels cost nothing; history in D1, files in R2. |
| 1646 | - Agents are members. `@g1t` in a channel starts work, answers, or |
| 1647 | posts a summary; agents post their questions and handoffs where people |
| 1648 | already are. A thread becomes an issue or an outcome in one action, and |
| 1649 | the agent's progress streams into that thread. |
| 1650 | - Tied to the work: issues, pull requests, runs and deploys each have a |
| 1651 | thread; links unfurl into live cards (checks, agent step, preview). |
| 1652 | What a channel settles can become workspace memory, with its source. |
| 1653 | - Apps: an installable PWA first (desktop and mobile, offline shell, Web |
| 1654 | Push), then native shells on the same API: Tauri for desktop (tray, |
| 1655 | deep links), React Native for iOS and Android (background |
| 1656 | notifications). |
| 1657 | |
| 1658 | GitHub-style Discussions are not planned: channels and threads on the |
| 1659 | work replace them. |
| 1660 | |
| 1661 | ## What GitHub ships today, and where g1t differs |
| 1662 | |
| 1663 | GitHub's Agent HQ and Copilot app give each agent session its own git |
| 1664 | worktree and branch, list sessions in a mission-control view grouped by |
| 1665 | project, and let a task be assigned to several agents so their output can be |
| 1666 | compared. Underneath, the unit of work is still a branch and a pull request. |
| 1667 | |
| 1668 | | | GitHub | g1t | |
| 1669 | | --- | --- | --- | |
| 1670 | | Where a session works | A worktree on one developer's machine, or a cloud sandbox | A server-side fork that any agent on any machine can join and anyone can open | |
| 1671 | | Agent context | Lives in the app's session view | Stored with the repository and linked from each commit (why-blame) | |
| 1672 | | Several agents on one task | Separate pull requests to compare by hand | One issue holding every pull request made for it, compared side by side, with the merged one recorded on the issue | |
| 1673 | | Collisions between agents | Found as merge conflicts at the end | Flagged during the work (overlap radar) | |
| 1674 | | Landing changes | One pull request at a time | A merge queue that lands the chosen one and closes the rest as superseded | |
| 1675 | | Which agents | Those offered through a Copilot subscription | Any MCP client, plus hosted agents | |
| 1676 | |
| 1677 | ## How agents connect |
| 1678 | |
| 1679 | 1. **Bring your own agent.** A remote MCP server at `mcp.g1t.sh` lets Claude |
| 1680 | Code (or any MCP client) list issues, claim one, get a clone URL and |
| 1681 | token, report progress and submit. Adding it is one command; sign-in is a |
| 1682 | browser OAuth flow with no token to paste. The `g1t` CLI installs Claude |
| 1683 | Code hooks that upload the session transcript as the agent works. |
| 1684 | 2. **g1t's agent.** Assign an issue to g1t, or many issues at |
| 1685 | once, each to an agent of its own. g1t starts a sandbox for each |
| 1686 | (Cloudflare Containers), running a coding agent headless against its |
| 1687 | own pull request and fork. |
| 1688 | 3. **API and CLI.** Everything above is available at `api.g1t.sh` and |
| 1689 | through `g1t`. |
| 1690 | |
| 1691 | ## Public surfaces |
| 1692 | |
| 1693 | | Host | What it serves | |
| 1694 | | --- | --- | |
| 1695 | | `g1t.sh` | The site, git over HTTPS, git over SSH | |
| 1696 | | `api.g1t.sh` | REST API, with no version in its paths, with a published OpenAPI document, cursor pagination, rate-limit headers, idempotency keys on writes, server-sent events for live pull request state, and signed webhooks | |
| 1697 | | `mcp.g1t.sh` | Remote MCP server over streamable HTTP | |
| 1698 | |
| 1699 | g1t is its own OAuth 2.1 authorization server: authorization code with PKCE, |
| 1700 | dynamic client registration that stores nothing (a client id encodes its |
| 1701 | own registration, so the open endpoint cannot be used to fill a database), |
| 1702 | discovery metadata and rotating refresh tokens. Still to come: scopes |
| 1703 | per resource (`repo:read`, `repo:write`, `issue:write`, `pull:write`). |
| 1704 | MCP clients, the CLI (device flow) and third-party apps all use it. Access |
| 1705 | tokens and SSH keys remain for git itself. |
| 1706 | |
| 1707 | ### Workspace aliases (internal, built 2026-10-07) |
| 1708 | |
| 1709 | `g1t` is the product; `flagon-io` is Flagon, Inc., the organization that |
| 1710 | builds it. So nobody mistakes one for the other, `g1t.sh/g1t` leads to |
| 1711 | `g1t.sh/flagon-io`. That is a workspace alias: a name g1t's staff point at |
| 1712 | a workspace, kept in identity's `workspace_aliases` (migration 0029, which |
| 1713 | seeds `g1t`) by the workspace's id, so it follows renames. It is not a |
| 1714 | customer feature and is not documented for users; staff add and remove |
| 1715 | aliases on sudo's Aliases page, with a reason, in sudo's audit log. We may |
| 1716 | give other companies one for a trading name the same way. |
| 1717 | |
| 1718 | An alias is resolved wherever an old slug is (identity's `resolve_slug`), |
| 1719 | so it costs only the not-found path: site pages 301 to the same page under |
| 1720 | the workspace, the API and MCP run the call again under its slug, package |
| 1721 | registries 301, and git over HTTPS is answered in place |
| 1722 | (`resolve_alias`), because pushes do not follow redirects. An alias is |
| 1723 | never a route, a username or a workspace's slug, and nobody can register |
| 1724 | it while it exists. `@g1t` stays g1t's agent: mentions link to how the |
| 1725 | agent works, never to `/g1t`. |
| 1726 | |
| 1727 | ## Architecture |
| 1728 | |
| 1729 | | Component | Language | Runs on | Responsibility | |
| 1730 | | --- | --- | --- | --- | |
| 1731 | | `crates/contracts`, `packages/contracts` | Rust, TypeScript | — | The interface of every service, the event catalogue, shared types. Services and clients depend on this, never on each other's code. | |
| 1732 | | `services/identity` | Rust | Worker + D1 | Accounts, workspaces and memberships, sessions, SSH keys, access tokens, device sign-in, OAuth codes and grants | |
| 1733 | | `services/repos` | Rust | Worker + D1 + Artifacts | Repository registry, contents, forks, diffs, landing, git over HTTPS. Storage sits behind a `GitStore` port with an Artifacts adapter. | |
| 1734 | | `services/work` | Rust | Worker + D1 | Issues, pull requests, comments, sessions; later a Durable Object per repo for the landing queue and live state | |
| 1735 | | `services/billing` | Rust | Worker + D1 + Stripe | Each workspace's agent credit: payments, the ledger of every run, and the gate on starting one | |
| 1736 | | `services/events` | Rust | Worker + Queues + D1 | The event bus: durable log, and one queue per subscribing service | |
| 1737 | | `services/runner`, `crates/runner` | TypeScript, Rust | Worker + Containers | Starts a sandbox per g1t run; the program inside runs the agent harness and reports through the public API | |
| 1738 | | `services/og` | TypeScript | Worker + Cache API | Social cards at `og.g1t.sh`: one PNG per page of the site and the docs (satori and resvg), looked up as an anonymous visitor, so nothing private appears on one | |
| 1739 | | `apps/web` | TypeScript | Worker | Server-rendered site. Holds no data; calls services over RPC. | |
| 1740 | | `apps/docs` | TypeScript | Worker (static) | Documentation and the API explorer | |
| 1741 | | `apps/api` | Rust | Worker | REST API (`api.g1t.sh`), MCP server (`mcp.g1t.sh`) and OpenAPI document, all generated from one list of operations; the OAuth endpoints | |
| 1742 | | `crates/sshd` | Rust | Container | Git over SSH, bridged to Artifacts | |
| 1743 | | `crates/merged` | Rust | Container | Trial merges, conflict matrix, landing merges (needs real git; the Artifacts binding is read-only) | |
| 1744 | | `crates/core` | Rust | native and WASM | pkt-line, packfile and diff code shared by the above and by the Worker | |
| 1745 | | `crates/g1t` | Rust | user's machine | CLI: auth, SSH proxy, Claude Code hooks, issues and pull requests | |
| 1746 | |
| 1747 | Storage: Artifacts for repositories (one fork per pull request), D1 for accounts |
| 1748 | and metadata, R2 for session transcripts and logs, Durable Object SQLite for |
| 1749 | per-repo coordination state. |
| 1750 | |
| 1751 | How the services fit together: |
| 1752 | |
| 1753 | - **Each service is its own Worker with its own database.** It deploys, |
| 1754 | scales and fails on its own. Callers reach it through a typed RPC binding |
| 1755 | to the interface in `packages/contracts`. |
| 1756 | - **Expected failures are values.** Every call returns a `Result`, so "not |
| 1757 | found" or "forbidden" crosses a service boundary as data. |
| 1758 | - **Side effects travel as events.** A service publishes what happened |
| 1759 | (`git.push`, `issue.opened`, `pull.merged`, …) to the bus and does not |
| 1760 | call other services to react. Each subscriber consumes from its own queue. |
| 1761 | Timelines, webhooks and automations read the same stream, which is what |
| 1762 | lets something like GitHub Actions be built on top. |
| 1763 | - **Every read takes the viewer.** Authorization is decided inside the |
| 1764 | service that owns the data, not by its callers. |
| 1765 | |
| 1766 | The Workers runtime scales request handling on its own, so the edge layer |
| 1767 | stays in TypeScript. Rust is used where there is real computation or a real |
| 1768 | protocol to implement. |
| 1769 | |
| 1770 | ## Languages |
| 1771 | |
| 1772 | The site is TypeScript. Everything behind it is Rust, compiled to |
| 1773 | WebAssembly for Workers and natively for containers and the CLI. Identity, repos, work, events and the API are all Rust. The one exception |
| 1774 | is the Worker that starts sandboxes, because Cloudflare's Containers |
| 1775 | library is TypeScript. Rust services speak a |
| 1776 | small JSON protocol over service bindings (`POST /rpc/<method>`), with the |
| 1777 | types in `crates/contracts`. |
| 1778 | |
| 1779 | ## Identifiers |
| 1780 | |
| 1781 | Every id is a [TypeID](https://github.com/jetify-com/typeid): a prefix naming |
| 1782 | the kind of thing, then a UUIDv7 in lowercase base32, such as |
| 1783 | `pr_01jb2k7x9hfq0b3zj0f5s2m8ra`. |
| 1784 | |
| 1785 | - The prefix makes an id self-describing and stops ids of different kinds |
| 1786 | being mixed up. |
| 1787 | - Ids sort by creation time as plain strings. In SQLite (D1 and Durable |
| 1788 | Objects) that keeps inserts at the end of the primary-key index instead of |
| 1789 | scattering them, and gives time-ordered paging for free. |
| 1790 | - The suffix decodes to a standard UUIDv7 for any system that wants one. |
| 1791 | - Ids are made by the service that creates the record, not by the database, |
| 1792 | so they work across services and can be assigned before a write. |
| 1793 | |
| 1794 | ## Events at scale, and audit |
| 1795 | |
| 1796 | The current event log is a single D1 database. That is fine for a |
| 1797 | prototype and wrong for the target: D1 is one writer and 10 GB. The design |
| 1798 | for volume splits storage by how the data is read. |
| 1799 | |
| 1800 | | Tier | Store | Holds | Read by | |
| 1801 | | --- | --- | --- | --- | |
| 1802 | | Hot | A Durable Object per repository, with SQLite | Recent events for that repo | Timelines, live pages over WebSocket | |
| 1803 | | Complete | Cloudflare Pipelines into R2 as Apache Iceberg | Every event, forever, partitioned by day and workspace | Analytics, standups, "ask", export | |
| 1804 | | Audit | The same R2 store, under object lock | Who did what, from where, with which credential | Compliance, investigation | |
| 1805 | |
| 1806 | - **No single hot database.** Each repository's recent events live with that |
| 1807 | repository, so load spreads across as many objects as there are repos. |
| 1808 | - **The complete record is files, not rows.** Iceberg on R2 has no practical |
| 1809 | size limit and is queried with SQL. |
| 1810 | - **Audit is a property of every event.** The envelope carries the actor |
| 1811 | (person, agent, token or system), the credential used, the request id and |
| 1812 | the source address. Audit entries for a workspace are hash-chained, so a |
| 1813 | removed or altered entry is detectable, and are written under a retention |
| 1814 | lock. |
| 1815 | - **Delivery is at least once.** Consumers are idempotent on the event id. |
| 1816 | |
| 1817 | ## Accounts and forge basics |
| 1818 | |
| 1819 | - Registration with email verification, sign-in, forgot password (Cloudflare |
| 1820 | Email Sending), Turnstile on public forms. |
| 1821 | - GitHub sign-in, SSH keys, access tokens, active sessions. |
| 1822 | - Profiles, public and private repositories, repository search (D1 full-text). |
| 1823 | - Rendered README, syntax highlighting, commit history, diffs. |
| 1824 | - Transferring a repository between workspaces (by id: its git store key |
| 1825 | never moves; every service follows `repo.transferred`; old paths redirect |
| 1826 | until reused) and deleting an empty, settled workspace (its slug is |
| 1827 | tombstoned, never reissued except to the person whose username it is). |
| 1828 | - Access: five repository roles (Read, Triage, Write, Maintain, Admin; |
| 1829 | the capability table follows GitHub's repository roles, 2026-10-08: |
| 1830 | branch protection and rulesets are Admin, labels and milestones are made |
| 1831 | with Write and applied with Triage, security alerts are Write), a |
| 1832 | workspace base permission (Read for new workspaces), the creator of a |
| 1833 | repository given Admin on it, outside collaborators and invitations. |
| 1834 | Membership as GitHub's organizations have it (2026-10-08): owners and |
| 1835 | members, promote and demote, transfer ownership, leave, a last-owner |
| 1836 | guard; billing manager and security manager on top of member; member |
| 1837 | privileges (who creates public and private repositories, whether |
| 1838 | repository admins change visibility, delete and transfer, and invite |
| 1839 | outside collaborators); two-factor authentication (TOTP and recovery |
| 1840 | codes) and a workspace policy that requires it, holding non-compliant |
| 1841 | people out until they turn it on. Every membership change, token, SSH |
| 1842 | key, OAuth grant and two-factor change is in the audit log. Teams are built on it (2026-10-07): visible |
| 1843 | or secret, nested up to 8 levels (child teams inherit their parents' |
| 1844 | roles), run by maintainers and owners. A team's role on a repository is a |
| 1845 | `repo_grants` row whose principal is the team, which identity resolves |
| 1846 | into the same `RepoGrant`s on each person, so `access::can` needs nothing |
| 1847 | new: the highest role wins. `@workspace/team` mentions tell the team's |
| 1848 | people; a team asked to review either asks everyone or picks people by |
| 1849 | round robin or load balance. |
| 1850 | - CODEOWNERS, read in both conventions (single-section, and sections with |
| 1851 | approval counts, optional sections and default owners) from the first of |
| 1852 | `.g1t/`, `.github/`, the root, `docs/` and `.gitlab/`. Owners are asked to |
| 1853 | review, the `g1t / codeowners` status lints a changed file, and branch |
| 1854 | protection's "Require review from code owners" holds merges, for people, |
| 1855 | agents and the queue alike, until each owning rule is approved. |
| 1856 | |
| 1857 | ## Built on Cloudflare |
| 1858 | |
| 1859 | | Need | Product | |
| 1860 | | --- | --- | |
| 1861 | | Repositories; a fork per pull request; data residency per workspace | Artifacts (forks, jurisdictions) | |
| 1862 | | Reacting to pushes | Artifacts event subscriptions on Queues | |
| 1863 | | Preview URL per pull request; deploy on merge | Workers for Platforms on `g1t.page` | |
| 1864 | | Site, API, MCP, git front end | Workers | |
| 1865 | | Per-repo coordination, live updates | Durable Objects | |
| 1866 | | Pull request lifecycles, automations | Workflows, Cron Triggers | |
| 1867 | | Agent sandboxes, SSH server, merge engine | Sandbox SDK and Containers | |
| 1868 | | Fast starts on large repos | ArtifactFS | |
| 1869 | | Model traffic, spend, budgets | AI Gateway | |
| 1870 | | Summaries, embeddings | Workers AI | |
| 1871 | | Context hub search | Vectorize | |
| 1872 | | Accounts and metadata | D1 | |
| 1873 | | Transcripts and logs | R2 | |
| 1874 | | Email, bot protection, keys | Email Sending, Turnstile, Secrets Store | |
| 1875 | |
| 1876 | ## Running g1t yourself |
| 1877 | |
| 1878 | g1t.sh runs on Cloudflare, and that does not change. The core is MIT and |
| 1879 | must also run on anyone's own machine with `docker compose up`. A free |
| 1880 | core people can self-host is what makes paid hosting worth trusting. |
| 1881 | Self-hosting never makes hosted worse: hosted code paths keep their |
| 1882 | behaviour, and a self-hosted adapter sits beside the hosted one. The |
| 1883 | inventory of every Cloudflare dependency, the design and the risks are in |
| 1884 | [SELF_HOSTING.md](SELF_HOSTING.md). |
| 1885 | |
| 1886 | The approach: the Workers stay Workers, and self-hosted they run in |
| 1887 | workerd, the open-source Workers runtime. D1, KV and Queues are SQLite on a |
| 1888 | volume, with the same migrations. Cloudflare-only bindings are replaced |
| 1889 | by stand-ins: |
| 1890 | |
| 1891 | - Artifacts becomes bare repositories served by `git http-backend`; |
| 1892 | - Email Sending becomes SMTP, through Mailpit; |
| 1893 | - services that are off answer "off" instead of failing. |
| 1894 | |
| 1895 | | Phase | Scope | Estimate | |
| 1896 | | --- | --- | --- | |
| 1897 | | 1. Core forge | Done: `deploy/self-host/` (compose, git store, binding stand-ins, smoke test) and the "Run g1t yourself" guide. Left: the API on its own port, `PUBLIC_URL` in place of hard-coded hosts, cron, pull requests in the smoke test, CI that runs it. | 1–1.5 weeks left | |
| 1898 | | 2. Agents | Docker sandboxes with the same runner image, an egress allow-list proxy for guardrails, `g1t.toml`, a launcher in place of `wrangler dev` | 2–3 weeks | |
| 1899 | | 3. Search, context, deployments | sqlite-vec plus an OpenAI-compatible embedder; an app host on workerd; Caddy for app and custom domains; SSH | 3–4 weeks | |
| 1900 | | 4. Parity and upgrades | Code-level ports in `g1t_kit` and `@g1t/platform`, sudo without Access, online backups, released images, an upgrade test in CI | 3–4 weeks | |
| 1901 | |
| 1902 | ## The submission |
| 1903 | |
| 1904 | - **g1t is built on g1t.** This repository is hosted on g1t.sh, its features |
| 1905 | are opened as issues and built by racing agents, and it deploys from |
| 1906 | Artifacts through Workers Builds. The history is the proof. |
| 1907 | - **The demo follows one story.** A brief becomes a project; twelve issues |
| 1908 | fan out to dozens of agents; agents notice each other, hand off, and |
| 1909 | resolve a conflict; reviewers triage; the queue lands everything on |
| 1910 | `main`; why-blame explains a line; the portfolio shows where it all |
| 1911 | stands. Then the same thing at a thousand agents. |
| 1912 | - **Judges can try it in a minute.** Open registration on g1t.sh, one-click |
| 1913 | import of a GitHub repo, one command to connect Claude Code, a seeded demo |
| 1914 | workspace, and a single deploy command for running their own copy. |
| 1915 | - **The formats are open.** The commit trailers, session format and runner |
| 1916 | contract are published so other tools can interoperate. |
| 1917 | |
| 1918 | ## Build order |
| 1919 | |
| 1920 | What is left is ordered by how much it shows the point above, not by forge |
| 1921 | parity. Forge basics are done well enough; each item below should make the |
| 1922 | demo's story stronger. |
| 1923 | |
| 1924 | Done from this list: the outcome page (a plan's issues as a live graph with |
| 1925 | cost and a feed of what happened), coordination you can see (agents' issues |
| 1926 | and comments stand out in the feed; agents hold g1t's tools through a token |
| 1927 | scoped to one repository), steering a running agent (messages delivered |
| 1928 | between steps, and at the end), and recording sessions from anyone's own |
| 1929 | Claude Code (`curl -fsSL https://g1t.sh/install/claude.sh | sh`). Integrations are |
| 1930 | in: a workspace's own model provider (Anthropic or any Anthropic-compatible |
| 1931 | endpoint, reached through a model proxy so no sandbox holds a key; its |
| 1932 | runs pay only their sandbox time), alerts from Sentry, Datadog and signed webhooks |
| 1933 | that open one issue per problem and can start an agent, and Jira and Linear |
| 1934 | tickets that agents read, people import, and that hear back. Racing a |
| 1935 | set number of agents on one issue is dropped: choosing how many agents to |
| 1936 | use is not something people should have to do. |
| 1937 | |
| 1938 | 1. ~~**Handoffs and questions between agents** as states on the outcome |
| 1939 | page.~~ Done: questions and handoffs show as waiting, read, answered, |
| 1940 | taken on or declined; since 2026-10-03 an agent asked while it is not at |
| 1941 | work is woken to answer, where before the question waited forever. |
| 1942 | 2. **Upkeep agents** (above): dependency updates, secret scanning, |
| 1943 | vulnerability alerts, code scanning, the security page. No new |
| 1944 | infrastructure. |
| 1945 | 3. **Deployments on `g1t.page`** (above): previews per pull request, |
| 1946 | production on merge, the reviewer agent checking the preview. |
| 1947 | 4. **The large run, building 2 and 3.** About 20–30 issues on g1t itself, |
| 1948 | built by agents and landed through the queue, for the video: g1t built |
| 1949 | on g1t. |
| 1950 | 5. **Polish for judges trying it in a minute:** a seeded demo workspace, the |
| 1951 | empty states, and the first-run path from sign-up to an outcome landing. |
| 1952 | |
| 1953 | Earlier items still open, after those: |
| 1954 | |
| 1955 | 1. Deleting a branch once its pull request merges; risk tiers. (Approval |
| 1956 | rules per path are in, as CODEOWNERS.) |
| 1957 | 2. Event storage per the design above: per-repo hot log, Iceberg on R2, |
| 1958 | hash-chained audit. |
| 1959 | 3. CLI with Claude Code hooks to record sessions automatically. |
| 1960 | 4. Reviewing and catching up automatically, by policy; required reviews; |
| 1961 | risk tiers. |
| 1962 | 5. Compare view, proof bundles; handoff between agents. |
| 1963 | 6. Projects, mission control, steering; why-blame, digest, timeline. |
| 1964 | 7. Context hub, portfolio; automations and integrations (Sentry first). |
| 1965 | 8. SSH; bot protection; own keys, endpoints and runners. |
| 1966 | 9. Large run (100+ agents across many issues), hardening, demo. |
| 1967 | 10. Passkeys (WebAuthn) as a second factor and for signing in: feasible on |
| 1968 | Workers (P-256 and RS256 verification in Rust, or WebCrypto), next |
| 1969 | after TOTP. Then fine-grained tokens, deploy keys and package access. |
| 1970 | |
| 1971 | Later: code search, mirroring to GitHub, SSH |
| 1972 | on port 22 without the CLI proxy (needs the Workers inbound TCP private |
| 1973 | beta). |