Know which lines the AI wrote.

Recorded when the AI writes it, not guessed afterwards.

Detecting AI code after the fact is unreliable. Grain hooks into the agent instead, so provenance is captured at the source and travels with the commit.

1. $ grain hook install

   Install the hook once

   A git post-commit hook plus a Claude Code hook. From then on, every line the agent writes is logged as a content hash, never as text.

   $ grain hook install

   ✓ installed .git/hooks/post-commit

   Add this to .claude/settings.json so AI edits are captured at the source:

   {

   "hooks": {

   "PostToolUse": [{

   "matcher": "Edit|Write|MultiEdit",

   "hooks": [{ "type": "command",

   "command": "command -v grain >/dev/null 2>&1 && grain hook claude || true" }]

   }]

   }

   }

   From then on every commit is attested automatically. Try: grain blame <file>

   $
2. $ git commit

   Commit as usual

   The hook matches the commit's added lines against the ledger and writes a signed note: exactly which lines were AI-written, bound to that commit.

   $ git commit -m "feat: signed provenance standard"

   grain attest 5f49f3c: Provenance: assisted, 889/961 added lines AI-written

   note on refs/notes/grain, signed 336b33f8517eb53b

   push it with: git push origin refs/notes/grain

   $ git notes --ref=grain show HEAD

   Provenance: assisted

   AI-Lines: 889/961

   AI-Hashes: 0320d2bd7a,1c9e0f77b2,3a8f1c02de,…

   Signed-By: ed25519:gsnAw0076ceAPFu8U35z7QjoQYD8ZTrNksSjzdPF6B4=

   Signature: ikJWlrLo5T6OlaBlxNr9brS5D5n1qBo5aLnd7aTJlP92Ieak…

   $
3. $ grain verify

   Check it, anywhere

   Any clone can verify every attestation offline. A note that was edited or moved to another commit fails. Teams list trusted keys in .grain/signers.

   $ git clone https://github.com/FrontTribe/grain && cd grain

   $ git fetch origin refs/notes/grain:refs/notes/grain

   $ grain verify

   grain verify: 91 commits, 14 attested

   signed, valid 5

   signed, invalid 0

   unsigned 9

   ✓ every attestation checks out

   $

A calm comment on every pull request.

Add the GitHub Action and each PR gets an itemised note from grain: how much of the change carries AI signals, whether it touches paths you marked human-owned, which dangerous-looking lines an AI wrote, which packages it added and whether the registry knows them, and what your policy asks for. Framed as signals, never as an accusation.

Provenance report · PR #3
100% AI-assisted · 1 commit, 11 lines changed
sandbox/                     0% human · 100% AI

policy  change set above the 40% AI threshold → review suggested
policy  1 security finding in AI-written lines → a human should look
policy  1 added dependency not on the registry → a human should look

security      7b49393 sandbox/fetch.py
              TLS verification disabled (high)          AI
dependencies  leftpadd-utilz   pypi   AI   not found
              requests         pypi   AI   5691 days old

name: Grain
on: pull_request
permissions:
  contents: read
  pull-requests: write
jobs:
  provenance:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: FrontTribe/grain@v1

Built for the three people who get asked about AI code.

The questions people ask before they run it.

Does my code leave my machine?

Not with the CLI: it reads your git history locally and writes two files into the repo. The edit ledger stores content hashes, never text. Cloud reads repositories through the GitHub App you install, with read-only access you can revoke.

Can it be wrong?

Inference can, which is why it is capped at 0.70 confidence and always labelled. Attested and declared provenance are records, not guesses. Every report separates the three so you can see what rests on what.

What about code written before the hook existed?

It is scored from what git already knows: Co-Authored-By trailers, bot accounts, tags, then capped inference. Lines nobody attested are shown as human, never claimed as AI.

Will it slow down commits?

The post-commit hook hashes the lines the commit added and writes one note. On this repository that is a few milliseconds. Nothing runs in the editor loop.

Does it catch security problems?

It catches the lines that make vibe coding dangerous: a pasted token, TLS verification turned off, a shell or SQL command built from input, unsafe deserialization, wildcard IAM. When Claude Code writes one, grain tells the agent before the commit; every report says which of these lines an AI wrote and whether anyone reviewed them. It also lists the dependencies AI-written lines added and asks the registry whether each package exists and how old it is, the slopsquatting check. It is not a vulnerability scanner, and it says so next to every finding. In a pull request, two lines in .grain.toml decide whether these findings warn or block the check.

Which agents does it capture?

Claude Code today, through its PostToolUse hook. The ledger format is a JSON line per edit, so any tool that can run a command after writing a file can attest.

Is it really open source?

The engine, CLI, GitHub Action and the provenance format are MIT, in one repository. Cloud is the hosted dashboard, alerts and signed reports on top of the same engine.