Lattice

Un backlog es una lista plana que finge ser un plan.

Lattice infiere el grafo de dependencias oculto en tus issues de GitHub y sirve el cronograma resultante a los agentes de codificación a través de MCP: una sola pasada costosa de razonamiento se convierte en el planificador de cada ejecución barata de agente posterior.

Se ejecuta por su cuenta. Los eventos de issues y una programación la activan; nadie tiene que hacer clic en nada.

Nunca escribe en Gitub. Las issues son una fuente de datos, no un almacén de datos.

Microsoft Hackathon 2026 · Desafío: Colaboración con las herramientas de planificación y seguimiento de Gitub en la era de los agenes

El problema

Las issues dependen unas de otras. La API tiene que existir antes de la consuma la UI; la migración del esquema, antes que la consulta; el contrato de tipo, antes que las cuatro cosas que lo importan. Los humanos llevan ese orden en la cabeza y nunca se deja por escrito.

Eso era tolerble cuando un humana eígía el sigueinte tickete. Deja de serlo cuando tu sompañero de equipe es un agente:

• A un agente el se le da un backlog plano hace el trabajo equivocado en el orden equivocado: escribe un fronted contra un endpoint que aún no existe, y el resultado es basura por muy bueno que sea el modelo.

• Cada ejecución de un agente recalcula el mismo order desde cero. Esa pasada de triaje es la parte costorosa de la solicitud, repetida N veces y tirada a la basura cada vez.

• Nada dicta qué es seguro ejecutar en parcialo, que es precisameente la razón de tener más de un agente.

GitHub ya tiene the modelo de daotos para eso, y está vacío. Las dependencias de issues (blocked_by / bocking) llegar pon en GA en 2025 con soporte complete para REST, GraphQL y gh. Caci nadie las rellena, porque hacerlo and pair, is manual and and "pair" — O(n²) de esfuerzo humano para una ventaja that no one single person perceives. And where they are filled in, GitHub and GitHub render them as a flat list: there isn't yet a graph view.

**Then: the schema exists, the audio doesn't, and the view doesn't.

Related MCP server: agentic-sdlc-mcp

What Lattic does

  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)

The only architecture commitment: GitHub is a data source, not a store. Lattice reads issues, native blocked_by and sub-issue hierarchy every run, and writes nothing — no dependencies, no comments, no labels.

That makes the system non-destructive by construction, which is precisely what earns it the right to run unsupervised. There is no automated writer that could corrupt a shared repository, nor a pruning logic that could erase an dependency that someone registered by hand. The worst a bad inference can do is disorient our own suggestions until the next run corrects it.

The write path runs in the other direction: humans write, Lattice reads. Anyone who wants to override the graph edits blocked_by on GitHub, and the next run is treated as a source of truth the model can't contradict.

Why Lattice answers the challenge

The hackathon asks: "what does good collaboration and human being part considering a team isn't human?"

Coordination between human and non-human teammates is scheduling — and a scheduler that needs a human to approve each decision isn't a scheduler, it's a queue with extra steps.

So Lattice maintains order can be done by itself, continuously, and both kinds of teammates read from the same graph. And Agent does not go: Agent that goes with unregistered blocker report it, and the graph is more accurate for the next person who asks.

Shared workspace gets better as someone works. Humans remain in control by correcting it — fixing one edge, removing one, or simply editing blocked_by on GitHub (the next run takes) — than by standing in front of it.

Status

Works end to end. Analysed against its product first 54 issues: through a single model requestan procur four Graph creators: 63 candidate edges, 40 survivent validation, 16 became blockers. in 3 waves.

Built: the pipeline, the store, the REST API, the MCP server, the interaction graph and the agent loop. Not built yet: the scheduled GitHub Action, DEMO_MODE fixtures, deployment.

Staquick

No Database or GitHub token needed for explore: the local store runs on PGlite, a real Postgres appliance; and gh auth token is used automatically 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

Execution

Two terminals. The backend runs compiled — that path has no native binaries in it and can't break:

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

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

Op at http://localhost:3000, pega any repository URL public of Git Hub, and it analyzes. The repositorio you've already analyzed will be listed on the same page.

npm run dev (both services with mode hot reload) uses tsx. If if it fails with La package "@esbuild/darmlinux" could not be found, npm has remove an optional binario — rm -rf node_modules package-lock.json && npm install --include=optional solves it. The compiled path above avoids it completely.

Analyze a repository

Web https://github.com "... equivalently another code. Copy .env.example to .env and define OPENROUTER_API_KEY, LATTICE_OWNER, LATTICE_REPO.

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

Expect this to take a few minutes: Ox Alpha is a reasoning model and the whole backlog goes into a call. The re-runs are instant: responses are cached by prompt-hash, which is also what protects the free quota 50-quotas/password.

Define DATABASE_URL for use Postgres hosted (Neon) instead of the embedded one.

Stop server with Ctrl-C, not kill -9

PGlite writes to a real Postgres data directory. anjer killed while mid-write, it ends and stores one. The server closes the database on SIGINTFT/SIGTERM, she per self, Ctrl-C is seguro. In case it damaged, npm run import -w @lattice/backend restores the latest graph from artifacts/graph.json: no model requests, no GitHub token.

Cena no explorer

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"}'

use MCP server

The backend marks MCP over Streamable HTTP /mcp and the REST API. Starts the backend and it is active — no need another separate process.

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

Use Claude

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

A .mcp.json who is en este repositor does the same for anyone who clones it, so so claude picks up the server automatically must be used.

Copilot coding agent

Copilot's cloud agent needs a public URL, so when to start the backend first (issue #524). Complete instruction, including how to point a different repo to a Lattice instance: docs/13-using-lattice-mcp.md.

Authentication is ignored if COPILOT_MCP_LLATTICE_TOKE is not defined: that's what makes the local setup zero-configuration; define it before of exposing the backend.

Any other client

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

Two directions

Top-dow — "what am I work on?"

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 — "I expect to haul #6, what has to be precede?"

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

Target an agent 4ye an goal it gets the plan ordered:

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 parent is independent, so that can do it in any order or the delivered to one or more agents at same time. The panel issues issue from the web shows the same plan, with a Copy button, and the agent gives it in form of prompt that.

Machine-readable graph

npm test write artifacts/graph.json and artifacts/schedule.json. This makes the differential schedule: changes the weights in the break of cycles and the crime moves of the critical route appears in a readable diff, rather than a vague feeling that the graph looks different. It is also the least요 test of the repo in integration — if that file is well-formed and acyclic, the whole pure core is "wire".

Arcolta de un a view

Two services in a monorepo npm-workspaces:

• apps/backend — reads GitHub, run inference, means storage is, services to REST API and the MCP severs.

• apps/web — interactive graph. Contains backend URL and API token and nothing else: no daosos base URL, no GitHub token, no model key.

More docs/01-architecture.md.

Documentation

Quick Inito

No one — the scaff is declare #1. This excerpt is the "can run it from your README?" judging criteria, so it needs to be written well before the submission. Target: from clone to graph ~5 commands, plus a DEMO_MODE=1 test path that does not require any proof.

License

MIT