---
title: "Cork vs git log and GitLive: what git never sees · Cork"
description: "Cork vs git log and GitLive: git log records commits and GitLive shows people their teammates' uncommitted changes; Cork tracks agents' changes per symbol as they write, and keeps the process."
canonical: "https://corkcli.com/blog/cork-vs-git-log-and-gitlive"
last_updated: "2026-11-14"
published: "2026-10-19"
author: "Kevin Vera"
---

# Cork vs git log and GitLive: what git never sees

Cork vs git log and GitLive: git log records commits and GitLive shows people their teammates' uncommitted changes; Cork tracks agents' changes per symbol as they write, and keeps the process.

By Kevin Vera · October 19, 2026 · [Comparisons](https://corkcli.com/blog/c/comparisons) · 7 min read

How is Cork different from git log and from GitLive? git log records what was committed: the tidy end of each story. GitLive shows human teammates' uncommitted changes in their IDE and warns about merge conflicts before they happen. Cork works one level down, for AI coding agents as well as people: it tracks what every agent is changing, per symbol, as it writes, tells the other agents before they collide, and keeps a record of the process git never sees. git stays the source of truth for code; Cork is the record of everything between commits.

## Cork vs git log at a glance

| Question | git log | Cork |
| --- | --- | --- |
| When do you find out about a change? | After it is committed | When it is written: other agents hear about a rename or new signature on their next step |
| Work in progress | Invisible until commit | Every edit an agent makes is reported as it happens, including uncommitted work |
| Reads and commands | Never recorded | What each agent is reading, searching and running, live, next to its edits |
| Cost | Not recorded | Tokens per session and per model, with an estimated cost at list prices, rolled up per day, model, person and top-level directory |
| Blame | Who and when | Who, when and why: rationales, notes anchored to the code, scars |
| Failed attempts | Gone after a revert or rebase | Kept in the ledger, and mined into scars: what was attempted, by whom, and who reverted it |
| Conflicts | Found at merge time | Before a write, an agent is warned or held if a teammate renamed, removed or re-signatured a symbol in that file, and told the new name and signature |
| Audience | People reading history | Agents adapting mid-task, and people on a dashboard |

## What git log does well, and what it cannot see

git log is the record of outcomes, and it should stay that way: content, authorship, commit ids, an auditable history everyone already trusts. Cork does not replace any of it.

What git log cannot hold is the process. When several AI agents and people work one repository, most of what matters happens between commits: who is editing which function right now, what an agent tried and reverted, why it chose one approach, what the session cost. None of that reaches a commit. An agent that starts work at 10:02 cannot learn from git log that another agent renamed the function it is about to call at 10:01, because that rename is not committed yet.

Cork's ledger is append-only and hash-chained. Every edit an agent makes is reported as it happens and appended, including uncommitted work and edits that were later reverted. The ledger stores the structure of each change (symbols, signatures, line hashes), not the file text: Cork's hooks send structure only, and the server keeps no source lines.

## What is GitLive?

GitLive is a plugin for VS Code and JetBrains IDEs that shares teammates' local changes in real time. In its own words: "Preemptive merge conflict detection identifies conflicts as you code together," and "Gutter indicators in your editor show the lines that have been changed on other branches." It can cherry-pick a teammate's change from the gutter, compares your branch against all others "without needing to fetch", and uses end-to-end encryption so that "nobody in between, not even GitLive" can read what you share. It connects to GitHub, GitLab, Bitbucket and Azure DevOps.

GitLive is built around showing people their teammates' in-flight work inside the editor. We found nothing on its site, docs or extension listings about AI coding agents or MCP.

## Cork vs GitLive at a glance

| Topic | Cork | GitLive (as of October 2026) |
| --- | --- | --- |
| Who it is for | AI coding agents and the people running them | People working in their IDEs |
| How it connects | Hooks in Claude Code, Codex and Cursor, plus an MCP server for any MCP client | IDE plugin for VS Code and JetBrains IDEs |
| Granularity | Symbols: function and class names, signatures, callers | Lines changed on teammates' branches, in the gutter |
| What happens on a conflict | The agent is told before writing, and an edit against live work is held | You see a conflict warning in the editor |
| Memory | Hash-chained ledger, scars, rationales, notes anchored to code that go stale when the code changes | Live and snapshot views of current changes |
| Pricing | Free (local, and 10 agent hours a month in the cloud); $20 a month per 100 agent hours, pooled | Free tier (conflict detection limited to the 5 most recent branches); Personal $9/mo; Team $49/mo for 5 members; Enterprise $149/mo for 5 members; free for open source |

## Where GitLive stands out

- **In the editor people already use.** Gutter indicators and conflict warnings inside VS Code and JetBrains IDEs, with nothing new to learn.
- **Hunk cherry-picking.** Pull a teammate's change straight from the gutter.
- **End-to-end encryption** of what teammates share.
- **Works alone.** GitLive says you can use it "Even if your teammates don't yet."

## Where Cork wins

- **Built for agents.** An agent does not look at a gutter. Cork puts what changed into the agent's own context: a briefing before it starts and short deltas on its next step, with the new names and signatures.
- **It acts, not just shows.** The [write gate](https://corkcli.com/blog/write-gate) holds an edit against code another agent is changing right now, until the agent has the new version.
- **Symbol-level, not line-level.** A rename is a rename, wherever the lines moved; callers are tracked through the code graph.
- **The process, kept.** Scars, rationales, [anchored notes](https://corkcli.com/blog/shared-memory-coding-agents-anchored-notes) and per-session costs survive after the work is committed or reverted.
- **Your source stays home.** Hooks parse files on your machine and send structure only; Cork Free runs entirely on your machine.

## Can you use both?

Yes. GitLive serves the people in their IDEs; Cork serves the agents those people run, and the people too through its dashboard. They do not overlap in how they connect.

## Pricing compared

GitLive's pricing page lists Personal at US$9 per month, Team at US$49 per month for 5 members plus US$9 per additional member, and Enterprise at US$149 per month for 5 members plus US$19 per additional member, billed annually. On the free tier, "merge conflict detection is limited to the 5 most recent branches." GitLive is free for open-source projects.

Cork Free runs unlimited agents and repos on one machine with no account, with all data on the machine. Cloud Free gives each account 10 agent hours a month (30 bonus hours the first month), unlimited repos and agents, and a 30-day history window. Beyond that you pay for agent hours, not seats: $20 a month per unit of 100 hours, pooled across the workspace, graduated to $17 (units 11 to 50) and $15 (51 and up), with 15% off a year. Every member is a player, with teammates' machines, prompt-to-code matching by meaning, shared knowledge and 90-day history. Enterprise starts from about 100 units.

## Frequently asked questions

### Can git log show uncommitted changes from other agents?

No. git log shows committed history only. Cork's ledger records every edit an agent reports, as it happens, including work that never reaches a commit and edits that were later reverted.

### How do I see what my AI coding agents did today?

Cork's team dashboard (cloud plans) has an Activity view with a Sessions view: which agent ran, for how long, which files it touched, lines added and removed, the rationales it recorded, and what it cost in tokens. Agents can ask the same question in-session with the `recap` tool.

### Is Cork a GitLive alternative?

For AI coding agents, yes: Cork gives agents what GitLive gives people, awareness of teammates' in-flight changes, at the symbol level and inside the agent's own context, and adds a durable record. For people who want gutter indicators in their IDE, GitLive is the tool built for that.

### How much do my AI agents cost per feature?

Cork attaches each turn's token usage and model to the session, and rolls it up per day, per model, per person and per top-level directory, with an estimated dollar cost at list prices (not an invoice).

### Does Cork replace git?

No. git stays the source of truth for code. Cork records the process between commits: what happened, why, and what it cost.

## Sources

Checked October 19, 2026:

- <https://git.live>
- <https://docs.git.live>
- <https://docs.git.live/docs/admin/>
- <https://git.live/premium>
- <https://corkcli.com/data>
- <https://corkcli.com/docs/mcp-tools>

## Related reading

- [Cork vs Augment Intent: a shared plan, or live shared state](https://corkcli.com/blog/cork-vs-augment-intent): Cork vs Augment Intent: Intent coordinates agents around a living spec in isolated worktrees; Cork shares what every agent is changing, per symbol, as it writes.
- [From one machine to a team: moving from Cork Free to agent hours](https://corkcli.com/blog/cork-free-to-team): Move from Cork Free to agent hours: what changes when agents on teammates' machines see each other, how cork login and cork upgrade work, and what it costs.
- [Cork vs GitButler: sorting agents' changes, or keeping agents from colliding](https://corkcli.com/blog/cork-vs-gitbutler): Cork vs GitButler for parallel AI coding agents: GitButler sorts each agent's work into branches, Cork keeps agents from overwriting each other's code.
- [Cork vs Sculptor: an app for parallel agents, or a layer that keeps them from colliding](https://corkcli.com/blog/cork-vs-sculptor): Cork vs Sculptor: Imbue's Sculptor runs coding agents in parallel in isolated workspaces. Cork coordinates parallel agents and teammates on shared code.

[All articles](https://corkcli.com/blog.md) · [Cork in Markdown](https://corkcli.com/index.md) · [llms.txt](https://corkcli.com/llms.txt)

This page in HTML: https://corkcli.com/blog/cork-vs-git-log-and-gitlive
