Your git history knows everything. Your agent can't find any of it.

The Context Problem

You know the feeling.

You come back to a project after a week. You open your agent. “What would you like help with today?” You were halfway through implementing auth. The agent has no idea.

A new developer joins your team. They ask the agent to summarize what's been done. The agent scans 127 commits: fix, wip, updates, more fixes. Good luck with that handoff.

A reviewer opens your PR. They see fix: add null check. “Is that the right fix?” They have no idea why you added it. The commit doesn't say.

The information exists. It's in your git history. But it's trapped in a format that neither humans nor agents can efficiently extract.

Conventional Commits Are Not Enough

Conventional Commits solved a real problem. Before them, commit messages were chaos. Now we have structure: type(scope): description. Changelogs can be generated. Semantic versioning can be automated.

But Conventional Commits were designed for a different era. An era where humans read commit logs. An era before AI agents became daily coding partners.

The format answers what changed. It doesn't answer why. It doesn't say what's next.

Humans can read between the lines. Agents can't.

Four Problems, One Format

Agentic Commits extend Conventional Commits to solve four specific problems. The format is designed with agents in mind, but every improvement benefits humans too. Structured commits are easier to read, search, and act on - regardless of who's reading them.

Resume

“Where did we leave off?”

Context windows reset. Sessions time out. Agents crash. The work continues, but the memory doesn't. An agent reading standard commits sees completed work. It doesn't see the roadmap.

Review

“Why did we make this decision?”

Three months later, someone asks why you chose JWT over sessions. The decision made sense at the time. The reasoning is gone. Unless you wrote it down.

Handoff

“What’s the current state?”

New developer, new agent, new context. They need to understand what's done, what's in progress, and what's left. Messy commit history makes this archaeology. Structured history makes it a query.

Code Review

“Is this the right approach?”

A reviewer sees the code. They can evaluate syntax, style, correctness. But without knowing why you made a change, they can't evaluate if the approach fits the problem.

The Format

Agentic Commits add two optional elements to Conventional Commits:

type(scope): what (why) → next

Let's break it down:

• type(scope): what - Standard Conventional Commits. What changed.

• (why) - The motivation. Why this change was necessary. Enables Review and Code Review.

• → next - The continuation. What comes after this. Enables Resume. Only used with wip type.

A Real Example

Standard commit:

feat(auth): add token refresh endpoint

Agentic commit:

feat(auth): add token refresh endpoint (mobile sessions expire too quickly)

Now a reviewer knows why. They can evaluate if token refresh is the right solution for mobile session expiry. Maybe there's a better approach. The commit invites that conversation.

Work in progress:

wip(auth): add token refresh endpoint (mobile sessions expire too quickly) → add refresh token rotation

Now an agent - or a future you - knows exactly where to pick up.

Atomic Commits and Hunk Splitting

Format is half the story. The other half is granularity.

Most developers commit by file. Change three things in auth.ts? One commit. But those three things might be unrelated: a bug fix, a refactor, and a new feature. Bundled together, they're harder to review, harder to revert, harder to understand.

Agentic Commits encourages hunk-based commits. Stage by logical change, not by file. One file can produce multiple commits. Each commit tells one story.

The result: reviewers see focused diffs. Agents can trace specific changes. History becomes a searchable narrative instead of a pile of snapshots.

The Skill

Agentic Commits is both a specification and a skill. While it originated as a Claude Code skill, it works with most major coding agents: Codex, Cursor, Amp, Antigravity, and OpenCode. The skill automates the workflow:

• Analyzes your staged and unstaged changes

• Splits them into logical hunks

• Stages each hunk separately

• Writes properly formatted commit messages

• Chains commits with dependency awareness

But you don't need the skill to use the format. The specification works with any agent, any platform, any workflow. If your agent can write commits, it can write agentic commits.

Getting Started

For the full specification, installation instructions, and the skill itself, see the Agentic Commits project page.

This is v1.0.0. The format will evolve as agents evolve. But the core idea is simple: your git history is a communication channel. It's time to make it fluent in agent.