-
-
Onboarding a mature repo: Gemini drafts memory from years of issues and MRs; maintainers approve it onto a branch beside the code.
-
Tether mode: your local agent works the approved plan step by step; the server verifies each commit against CI and scope — not claims.
-
Onboarding a mature repo: Gemini drafts memory from years of issues and MRs; maintainers approve it onto a branch beside the code.
Inspiration
It's Monday. A new developer joins, points her AI at issue #41 — add rate
limiting to checkout — and gets a beautiful MR in twenty minutes. Token
bucket, Redis-backed, tests green. Except the team decided last March never
to add Redis, and a rate-limit helper already exists, built after an
outage. A reviewer rejects the MR and explains why in a chat thread — where
that explanation dies, waiting to be relearned in three months.
The repo holds all of the code and none of the decisions. Use cases,
direction, "why we don't do X" — they live in meetings and group chats,
invisible to every AI.
What made this feel urgent: the world just solved this for individuals.
Karpathy's "LLM wiki" went viral; people graphify their notes in Obsidian
and wire memory MCPs so their agent knows them. But nobody answered the
team question: who decides what the team's AI gets to believe? Let every
agent write to shared memory and it rots. Let nobody write and it stays
empty. We built Shiopan to close that gap.
## What it does
Shiopan is a closed loop for team context, native to GitLab and Google
Cloud:
- The ask — a developer comments @shiopan on an issue, like tagging a
teammate. - The plan — Gemini drafts a task plan from the issue plus the team's
approved memory: what to build, which files, which tests must pass. - The sign-off — a maintainer approves; the plan locks (immutable, content-
hashed). No one, human or AI, can quietly change it.
- The work — developers code with whatever AI they already use (live
today), or hand the plan to Tether: their own local agent works through it step by step (in the repo, runs in labeled simulation). - The check — the server verifies the work itself: CI pipeline green, diff
inside the approved scope. It never takes the agent's word for it. Three
failed checks -> a human takes over. - The payoff (planned) — what each task taught the team is proposed back
into memory, human-gated again. Decisions go in once and compound forever.
Team memory lives as graph-linked notes on a branch next to the code —
think Obsidian, for your repo's decisions — with role-based access and
human approval on everything that becomes team truth. A read-only console
shows the whole loop: memory, locked plans, audit verdicts, and the
invariants the system structurally enforces.
## How we built it
Google ADK + Gemini on Vertex AI — every reasoning step (issue briefs, init
memory, advisory notes) runs through one ADK agent layer; async-safe for
Cloud Run, with tool-using agents reading bounded, injection-guarded
context.
Cloud Run + Firestore + Secret Manager + Cloud Logging — the loop is an
always-on control plane. Approvals, locked plans, and strike counters live
server-side, where no individual session can rewrite them. That's why it's
cloud-native: governance on a laptop is a suggestion.
GitLab webhooks + API — issues and MRs are the interface; @shiopan commands drive everything.
MCP — Tether exposes two propose-only tools (next_goal / report_goal) so a
local Gemini CLI agent can drive the ladder while the server keeps the
verdicts.
Deterministic verification — pipeline status and diff-scope checks are
plain code, zero tokens. The LLM may word feedback; it never decides
pass/fail.
479 automated tests; the demo flow runs against a real GitLab repo.
## Challenges we ran into
Two ADK layers, one filename. Working in parallel, we independently built
two ADK integration layers that collided in the same file. We resolved it
by adopting the stronger one (async-safe, tool support) and extending it —
a live lesson in exactly the context-coordination problem Shiopan attacks.
We fired the LLM as a judge. Our first instinct was an AI QA agent.
Research and testing convinced us it's sycophantic and gameable — a coding
agent can talk a reviewer-model into "looks good," but it can't fake a
pipeline or hide files from a diff. We rebuilt verification as
deterministic code.
Cloud executors are environment-blind. We explored having a cloud agent do the coding and rejected it: it can't see your repo, your tooling, your real failures. That research produced Tether's shape — local execution, server- side verification.
The economics of autonomy. Live end-to-end Tether runs mean an agent
burning real tokens through fail-retry loops against CI. Within the
hackathon window we made a call: ship the core loop live, ship Tether fully
tested in a clearly-labeled simulation mode. That constraint taught us our
own design rule — the executor is expensive, so the governor must be free.
## Accomplishments that we're proud of
The core loop is deployed and working live: approved memory -> Gemini-
drafted plan -> human approval -> locked plan -> deterministic MR audit,
demonstrated on a real repo, including a true FAIL verdict catching out-of-
scope changes.
A verification design that can't be sweet-talked — and an honesty rule we
applied to ourselves: simulated verdicts are labeled demo-simulated, never
faked.
We ran our own governance on ourselves: no one merges their own PR; every
feature landed through review.
## What we learned
Context quality determines agent output more than model quality does —
without the team's decisions, AI defaults to one-size-fits-all code.
Individual AI memory is solved; team memory is a governance problem, not a storage problem: the unsolved question is who approves what becomes shared truth.
Evidence is a commit, not a claim. If a gate can be argued with, an agent
will eventually win the argument.
## What's next for Shiopan
First live CI-verified Tether run (the full autonomous ladder against a
real pipeline).
The loop-closer: proposing what each merged MR taught the team back into
memory, human-gated — making context compound automatically.
A context-aware advisory layer: the team's memory enriching corrective
feedback and MR audits (advising, never gating).
Deeper RBAC and multi-repo memory graphs for larger organizations.
Log in or sign up for Devpost to join the conversation.