lattice

Lattice

Ein Backlog ist eine flache Liste, die sich als Plan ausgibt.

Lattice leitet den Abhängigkeitsgraphen ab, der in deinen GitHub-Issues versteckt ist, und stellt den resultierenden Zeitplan Coding-Agents über MCP bereit – so wird ein teurer Reasoning-Durchlauf zum Scheduler für jeden danach günstigen Agent-Lauf.

Es läuft von selbst. Issue-Events und ein Zeitplan stoßen es an; niemand klickt irgendetwas.

Es schreibt nie nach GitHub. Issues sind eine Datenquelle, kein Datenspeicher.

Microsoft Hackathon 2026 · Herausforderung: Zusammenarbeit mit GitHub Planning & Tracking Tools im Zeitalter der Agenten

Related MCP server: agentic-sdlc-mcp

Das Problem

Issues hängen voneinander ab. Die API muss existieren, bevor die UI sie nutzt; die Schema-Migration, bevor die Anfrage existiert; der Typvertrag, bevor die vier Stellen existieren, die ihn importieren. Menschen haben diese Reihenfolge im Kopf – und sie wird nie aufgeschrieben.

Das war zu verkraften, solange ein Mensch das nächste Ticket ausgesucht hat. Nicht mehr zu verkraften, wenn dein Teammitglied ein Agent ist:

• Ein Agent mit einem flachen Backlog macht die falsche Arbeit in der falschen Reihenfolge – er baut ein Frontend gegen einen Endpoint, den es noch nicht gibt, und das Ergebnis ist Müll, egal wie gut das Modell ist.

• Jeder Agent-Lauf leitet dieselbe Reihenfolge von Grund auf neu ab. Dieser Triage-Durchlauf ist der teuerste Teil des Requests, N-mal wiederholt und jedesmal wieder verworfen.

• Nothing says what is safe to run in parallel – and it's the entire reason to have more than one agent.

GitHub has the data model for this, and it's empty. Dependencies (blocked_by / blocking) have become generally available in 2025 with full REST, GraphQL and gh support. Fast almost nobody enters them, because that is manual and pairwise work – O(n²) human effort for a benefit that no one feels. And where they are included, GitHub renders them as a flat text list; there is still no graph view.

Also: Das Schema exists, the data does not exist, and the view does not exist.

Was Lattice tut

  GitHub (read only)
  issues · blocked_by · sub-issues
             │
             ▼
  ┌──────────────────────────────────────┐
  │  BACKEND                             │
  │   inference ──► the full graph       │
  │                      │               │
  │        REST API ◄────┴────► MCP      │
  └──────────┬─────────────────┬─────────┘
             │ REST            │ MCP
             ▼                 ▼
     interactive graph    coding agents
     (human: what's next)  (agent: what's next,
                            what's parallel, claim)

Die eine architekturale Grundaussage: GitHub ist eine datenquelle, kein Datenspeicher. Lattice liest bei jedem Lauf Issues, native blocked_by- und Sub-Issue-Hierarchien und schreibt nichts zurück – keine Abhängen, keine Kommentare, keine Labels.

Damit ist das System konstruktionsbedingt nicht destruktiv – und genau das macht es überhaupt möglich, es unbeaufsichtigt laufen zu lassen. There is kein automatisches Schreiben, das ein geteiltes Repository verändern könnte, and keine Aufräumlogik, die eine von Hand erfasste Abhängigkeit löschen könnte. What a bad inference das Schlimmste what it does can do is to mis-ordering our own Vorschläge, until the next run corrects them.

Der Schreibpfad läuft in die andere Richtung: Menschen schreiben, Lattice liest. Jeder, der den Graphen überstimmen möchte, editiert blocked_by auf GitHub, und den nächste Lauf behandelt das als Ground Truth, die das Modell nicht widersprechen darf.

Why the challenge beantwortet

Das Hackathon fragt: „Wie sieht gute Zusammenarbeit aus, wenn ein Teil deines Teams nicht menschlich ist?“

Die Abstimmung zwischen menschlichen und nicht-menschlichen Teammitgliedern is Planung – and a Scheduler, der jede Entscheidung von einem Menschen genehmigen lassen, ist kein Scheduler, sondern a Warteschlange mit Extra-Schritten.

Also hält Lattice die Reihenfolge self – continuously – and both kinds of teammates read from the same Graph. Agenten don't just consume: An agent, der auf einen nicht erfassten Blocker stößt, meldet ihn zurück, and graph becomes more accurate for the next who asks.

Der geteilte Workspace wird besser, wenn jemand in ihm arbeitet. Menschen behalten die Kontrolle, indem sie ihn korrigieren – eine Kante fixen, eine unterdrücken oder einfach blocked_by on GitHub bearbeiten, was der nächste Lauf als Ground Truth erkennt –, instead of a picture.

Status

Funktionsends. Analysed against with its Own 54-Issue-Backlog: Eine Modell-Anfrage lieferte 63 Kandidatenkanten, 40 Hauben die Validierung, 16 wurden zu Blocking, über 3 Wellen.

Gebaut: the Pipeline, the Store, the REST API, the MCP-Server, the interaktive Graph and the Agent-Loop. Noch nicht gebaut: die geplante GitHub Action, demo fixtures, Deployment.

Schnellstart

Keine Datenbank und kein Token nötigt, um sich umzusehen: Der Store läuft auf PGlite (echte Postgres, eingebettet), and git auth token is automatically used if GITHUB_TOKEN is not set.

npm install
npm run build          # types + backend (tsc) + web (next build)
npm test               # 11 graph unit tests, then writes artifacts/graph.json

Starten

Zwei Terminals. Das backendend läuft kompiliert – dieser Pfad enthält keine nativen Binaries and does not break:

# terminal 1
npm run build && npm start -w @lattice/backend      # :3001

# terminal 2
npm run dev -w @lattice/web                          # :3000

Open http://localhost:3000, paste a URL any public GitHub repo and it will analyze it. All repos are ready to be analyzed and list on the same page.

npm run dev (beide Dienste mit Hot Reload) verwendet tsx. Wenn es mit The package "@esbuild/darwin-ARM" could not be found scheitert, has npm optional binary lost — Remove rm -rf node_modules package-lock.json && npm install --include=optional fixes. The compiled path above avoids this entirely.

Repo�analyse

Braucht einen OpenRouter-Key. Kopiere .env.example nach .env and setete OPROUTER_API_KEY, LATTICE_OWNER, LATTICE_REPO.

npm run analyze        # ~1 model request for a 50-issue backlog

Rechne damit, dass das a few Minuten dauert: Ox Alpha is a Reasoning model and the whole backlog goes in one call. Wiederholungen are instan – die Antworten werden per Prompt-Hash gecached, was auch the free tier quota of 50 Requests/Tag schützt.

Set DATABASE_URL if you want to use hosted Postgres (Neon) instead of the embedded one.

Stop the backend with Ctrl-C, not kill -9

PGlite writes to a real Postgres data directory. A hard kill during a write missing it and the store is gone. The server closing with SIGINT/SIGTERM, so is Ctrl-C safe. If it is destined, npm run import -w @lattice/backend restores the last graph from artifacts/graph.json – no model request, no token.

Prüfen won't break browser

curl localhost:3001/api/health
curl "localhost:3001/api/graph" | jq '.stats'
curl -X POST localhost:3001/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Den MCP-Server nutzen

The backend serves the MCP via Streamable HTTP under /mcp, accompanied by the REST API. You start the backend and it is live – no separate process.

npm run build && npm start -w @lattice/backend    # :3001, MCP at /mcp

Claude Code

claude mcp add --scope local --transport http lattice http://localhost:3001/mcp
claude mcp list          # lattice: ... - ✔ Connected

Ein committed .mcp.json the repository does the same for anyone who clones it, so claude the server automatisch finds.

Copilot Coding-Agent

The Copilot coding agent requires a public URL, so deploy the backend first (issue #52). Full guides, incl. how you can point a different repo into a Lattice instance: docs/13-using-lattice-mcp.md.

When COPILOT_MCP_LATTICE_TOKEN is unset, authentication is completely skip- selection completely, which makes local operation zero-config; set before the backend into public.

Any other client

npx @modelcontextprotocol/inspector    # then connect to http://localhost:3001/mcp

The two directions

Top-down — „Woran soll ich arbeiten?“

list_ready_work        issues nothing is blocking, ranked by how much they unblock
claim_next_issue       take one atomically, with a briefing; two agents never collide
report_progress        returns what your work just unblocked

Bottom-up — „Ich will #6 ausliefern, was muss zuerst existieren?“

plan_for_issue         the whole prerequisite chain, in build order
get_issue_context      blockers, dependents, and what they need from you
explain_dependency     why an edge exists, with the quote it was inferred from
report_dependency      a blocker you discovered; enters the graph for everyone

Point your agent on a target and it fills the sorted plan:

plan_for_issue(6)
  2 issue(s) must land before #6, in 2 step(s).
  step 1: #3  Put Adyen behind a PaymentProvider interface
  step 2: #4  Checkout session endpoint returns a provider-agnostic session
  then    #6  Native checkout in the app

Everything inside a step is independent, so it can can be done in any order or to multiple agents as once. The issue-Panel in the web app shows the same plan with a button Copy, which passes him as a Prompt you.

The machine readable graph

npm test creates artifacts/graph.json and artifacts/schedule.json . Das macht die Planung diffbar: Verändert man die Zyklus-Auflösungsgewichte, so shows the critical path shift as a reviewable diff, instead of a vague feeling that the graph has changed. It is also the cheapest test in the repo – if this file is wellformed and acyclic, the whole core is fully connected.

Erster Architecture Blick

Two servicesving in a npm-workspaces monorepo:

• apps/backend – reads GitHub, runs inference, owns store, serviert REST-API and MCP-Server.

• apps/web – the interactive graph. Contains the backend URL and API token and nothing els: no database URL, no token, no model key.

See docs/01-architecture.md.

Dokumentation

##Schnellstart

Not yet – the scaffold is issue #1. This section is the “Can someone else run it from my README?” criterion, so it will be written properly before delivery. Goal: clone to graph in ≤5 commands, plus a DEMO_MODE=1 fixture path that needs no tokens at all.

License

MIT