Think-Wide

first screen

Inspiration

Builders with several repositories keep re-solving problems they already solved somewhere else. Coding agents make it worse: each agent sees one repository, starts from zero context, and forgets every correction a human gave it last time. Pasting whole repos into a prompt is slow, leaks private code, and produces confident answers nobody can check.

What it does

Think-Wide gives a person or an agent a small set of tools over an authorized portfolio of repositories:

Browse an immutable snapshot of each repository.
Read exact evidence. A source reference is an address (repository, full commit, blob, byte range, sha256), never a paraphrase, so anyone can verify it.
Record a human decision that survives. A correction advances the investigation's revision and fences out any agent work computed against the old one. A late proposal from a stale run is rejected.
Export an implementation brief that a coding agent can act on inside the target repository.

Think-Wide reasons across projects; coding agents implement inside them. It never edits, builds, tests or deploys the repositories it reads. The same operations are available as MCP tools and in a web workbench, under the same authorization.

How we built it

One contract. Every operation is declared once in contracts/operations.json. Types, validators and MCP tool descriptors are generated from it, so the web app and an MCP host call the same operations. This let three people and several agents build in parallel without collisions.
Stack: Bun, TypeScript, TanStack Start, self-hosted Convex in Docker, generated MCP stdio adapters, WorkOS AuthKit, ast-grep in a bubblewrap sandbox, Biome, Vitest, Playwright, GitHub Actions.
Pre-existing infrastructure, reused rather than created for this event: a GalaxyGate VPS, a domain managed through Cloudflare, and a WorkOS account, all from the team's earlier projects. For this project we added a new staging environment and configuration inside them. No application code, data or credentials were carried over from those projects.
Agents in the build. One Claude Code session coordinated the GitHub board and ran adversarial QA on each pull request. Codex implemented the authorization backend and went through two adversarial rounds before merge. Codex and CodeRabbit reviewed pull requests, and every finding was answered as fixed, deferred or rejected. One AGENTS.md file instructed all of them.
Builder never verifies their own work. Each ticket had one owner and a different reviewer.
Model output is untrusted. It may only reference a closed catalog of UI components and evidence ids, never HTML, URLs or handlers.

What we tested

Every result is labeled with the level it was proven at.

Authorization (local, real handlers): user A reads A's data, user B reads B's. B using A's ID gets the same not_found as a missing ID, so nothing leaks about whether it exists. State was compared before and after by full table equality.
Effects, not just responses: a ledger checks what each operation actually did (rows, jobs, dispatches).
Revocation and stale work (local): revoking a grant mid-loop stops an in-flight run from publishing. A proposal from before a human correction is rejected.
Mutation checks: we deliberately broke revocation and the stale-run fencing in the production code, and the tests failed as they should.
Search sandbox (local): 25 of 25 analyzer isolation tests ran and passed, none skipped.
MCP (local, live host): real signed tokens with a five-minute lifetime, wrong audience rejected, and a real Claude Code host connected and called the tools.
Deployed: the container refuses unsafe configurations, an unauthenticated call is rejected, backup and restore were rehearsed, and WorkOS login works on the public site with the backend accepting the token.
Full gate: 591 tests in 41 files on the combined build, 0 failed. CI runs the same command we run locally.

Challenges we ran into

Convex evaluates local bundles with NODE_ENV=production, so our first production guard was in the wrong place. We moved it and tested it there.
Docker could not fetch signing keys from the host, so the public key set is passed as a data URI.
On one machine localhost and 127.0.0.1 reached different processes, which would have silently invalidated tests.
A scaffold command would have overwritten our schema and deleted the grant model. We caught it on a throwaway branch.
Eight hours. A feature freeze forced real cuts.

Accomplishments that we're proud of

19 merged pull requests and about 11,000 hand-written source lines in one day, with a green gate on the combined build.
Tests that are proven to catch a break, not just pass.
Evidence you can verify byte for byte.
An honest status page: anything we did not prove says NOT RUN.

Status at submission

Deployed

Hosted identity. WorkOS AuthKit login is live at https://think-wide.fbf.systems, with the self-hosted Convex backend accepting the WorkOS session token. It runs on our existing GalaxyGate VPS.

Local, real handlers

The contract (0.5.0) and generated operation pipeline, grants, decisions, run fencing, git snapshots with exact byte-range evidence, the workbench and frozen briefs, and the MCP server over stdio, verified from a real MCP client.
An HTTP transport for the same operations is merged. Its MCP endpoint stays unconfigured until a real OAuth token is verified.

NOT RUN

Remote MCP host (Claude.ai or ChatGPT over OAuth).
Search. Literal and structural search is built and sandboxed but not yet wired into the operation pipeline. The demo uses browse and exact reads.
Deployed demo data. The demo catalog is not seeded on the deployed backend, so a new login there sees an empty portfolio.
The demo video uses synthetic repositories and a local-demo identity.

What we learned

A contract-first design is what makes parallel human-plus-agent work possible.
Separating "who are you" (identity provider) from "what may you touch" (application grants) kept the authorization model testable without a live login.
Labeling status levels on every claim kept us honest with each other and cost almost nothing.
Independent verification by a person who did not write the code found real bugs.

What's next for Think-Wide

Unify the browser and MCP identities so one person sees their own work from both, and seed the deployed catalog.
Wire search into the pipeline.
Deploy publicly with one real remote MCP host.
Add grant expiry and decision categories.
Point it at real repositories under real grants.

Disclosure

Prior design work. Planning documents in docs/ were written before the event and are disclosed as such. Application code starts with this repository, which was created on the day of the event.
Pre-existing accounts and infrastructure. A GalaxyGate VPS, a domain managed through Cloudflare, and a WorkOS account already existed from the team's other projects. We reused the accounts only. The WorkOS staging environment, redirect settings and the server configuration for Think-Wide were set up for this project. No code, data or secrets from those other projects are part of this submission.
AI agents and review bots. Claude Code, Codex and CodeRabbit were used throughout, as