premiseTop
premise

Every edit restson a premise.

When someone else changes code your agent built on, git says nothing. Premise tells the agent what changed and what to fix.

git clone https://github.com/unshDee/premise && cd premise

Watch it happen

Two agents, two branches, one function. Git merges cleanly and the code is broken.

Different files. No conflict.

Agent A removes a parameter and lands on main. Agent B has added callers that still pass it, in files A never touched.

kernels.pyAgent A, landed on main
- def convert_weights(backend, weights, scale, input_dtype, group_size=GROUP_SIZE):+ def convert_weights(backend, weights, scale, group_size=GROUP_SIZE):
cpu.pyAgent B, on branch b
+ def serve_on_cpu(layer):+     return convert_weights("cpu", layer["weights"], layer["scale"], input_dtype="bf16")

Git merges B without a conflict. The merged code raises TypeError.

Modelled on a real break in vllm: #65542 and #63711 were both green, merged cleanly, and broke main until #65810.

How it works

Premise records what each agent's edits rest on, in a Relate graph. Only deterministic code writes to it.

  1. 1 of 4

    A hook records every read and edit, and what shell commands change.

  2. 2 of 4

    Each edit is linked to the version of the code it calls. Here, B’s new line rests on total(price).

  3. 3 of 4

    A’s change lands on main. One traversal finds every edit that rests on a changed version.

  4. 4 of 4

    The agent is told at the end of its turn, and fixes its callers.

Does it help?

Real agents on seven real collisions, 21 runs each way.1 How many times the merged code worked:

0of 21

Told nothing

10of 21

Told “name changed on main”

19of 21

Given Premise's briefing

7 of 12

real collisions where the check named the call that broke. The five it missed are changes in what a function returns or does.2

Built on

The graph lives in an embedded Relate store in your repository. No server, no configuration.

Which edits on branch b rest on convert_weights
relate --read-only -d examples/demo.rl "MATCH (e:ToolCall {branch: 'b'})-[d:RESTS_ON]->(v:SymbolVersion {name: 'convert_weights'}) RETURN e.id, e.path, d.via, d.callers"
sess-b_03, cpu.py,       import, ["serve_on_cpu"]
sess-b_04, width_log.py, import, ["log_width"]
sess-b_05, test_cpu.py,  import, ["test_cpu_conversion_keeps_every_weight"]

How Relate is used

Relate, Neo4j and their logos are trademarks of Neo4j, Inc., used here only to identify the product. Premise is an independent hackathon entry and is not endorsed by Neo4j.

Try it

Three commands. The last one replays the race on a local page.

git clone https://github.com/unshDee/premise && cd premise
uv venv --python 3.12 .venv && uv pip install --python .venv/bin/python -e .
.venv/bin/premise demo --watch

The demo's sessions are replayed hook payloads, not live agents. Hooks ship for Claude Code, agy and Codex CLI: using it on your own repo.

The premise watch page, laid out like a desktop git client: the edits recorded on branch b on the left, the selected edit's code in the middle with the stale call to convert_weights marked, and Premise's report on the right reading 3 edits will break. A small branch graph and replay controls sit underneath.
The page that premise demo --watch opens.

Questions

Which languages does it support?

Python, at the level of single functions. It parses with tree-sitter, which has grammars for most languages; Python is the one wired up today. Every other file is already tracked as a whole-file hash.

What kinds of change does it name?

The ones that break callers without a git conflict: a function that gains or loses a parameter, or is renamed or removed, plus the literals and errors visible in its body. A change in what a function computes or returns is not named yet.

Does it follow every call?

It follows calls through imports and same-file names, and method calls where the code ties the object to a class by name. Inherited methods, values returned from calls, dynamic dispatch and star imports are not followed yet.

Who gets told, and when?

The agent whose code went stale, at the end of its turn and before it merges, while it still has the context to fix it. The other direction, when the function's author merges last, is checked in the replay and is not live yet.

Does Premise use a model?

No. The recorder and the check are deterministic code, so the graph holds only what happened, never a guess. It tracks that a flagged call was rewritten; judging whether the rewrite is right stays with your tests.

Why not rely on tests or a merge queue?

They run after the work is done, and catch a break only where a test happens to cover it. Premise tells the agent earlier, and names the function that changed and the calls that rest on it. It works alongside them.

  1. What this test does not show. The judge checks that calls bind and removed names are gone; it does not run tests or check behaviour. Three runs per cell, one model (Claude Sonnet), seven cases; in three cases the roles are swapped. The agent told nothing has no reason to look at main, so its zero is the baseline, not a finding. The agent's earlier work is replayed into the graph, not recorded from a live session. ↩
  2. What I do not claim: how often this happens. I replayed 1,950 merged PRs from 13 repositories. Of 619 where the base had moved under new Python code, the check would have briefed the agent on one, and none of the candidates I read by hand was a real break. The twelve cases show it happens, not how often. Method and raw rows ↩