AI writes code. Humans write software.

Igni is the intent layer for teams running agents on code that matters.

Git for code. Igni for intent.

01 The work pushes back.

A concrete tradeoff surfaces while the coding agent keeps building.

The execution layer is here. The intent layer is missing.

Coding agents don't just write code. They make calls your team has to own.

Every run decides what to preserve, what to break, and which constraints matter. Those calls are your intent.

If those calls only show up in the diff, you're approving code, not directing software.

Context, review, and memory all help. None gives those calls a place to be shaped and owned while the coding agent keeps building.

Igni surfaces the call when the work pushes back on intent. The coding agent keeps building. The team makes the call in Igni. The code moves, or the constraint does.

Not better context. Infrastructure for intent.

Graph. Stage. Loop.

One layer. Three jobs.

Igni reconciles owned intent with what the code reveals. Coding agents keep building; in Igni, people and the Igni agent resolve the open choices the work exposes, and owned changes connect back to the work they affect.

01

Intent Graph

Connect goals to code.

Goals, features, and code stay connected.

Igni connects product goals to the features and code that realize them.

Decisions, constraints, and what the work reveals shape that structure: connected intent, not a note in an agent's memory.

Without it: every run guesses what matters.

A graph showing an owned call connected to product goals, features, and code work.
Graph-connected intent
A CLI characterization run showing codebase structure written from source evidence.
Codebase characterization
02

Intent Stage

Edit intent together.

Your team and the Igni agent edit intent together.

Multiple teammates and the Igni agent can edit the same intent at once: draft options, tighten constraints, and see what each change touches.

Coding agents keep building; only owned changes become the standing record.

Without it: human judgment becomes review after the fact.

A teammate editing intent in Igni.
Teammate live edits
The Igni agent editing the same intent in Igni.
Igni live edits
03

Intent Loop

Let findings flow back.

Coding agents build from intent. Findings flow back.

Your coding agents keep working in their own tools. Igni gives them current intent to build from, and findings from the work flow back without blocking them.

Change intent or code, and Igni recomputes the work touched by that change, like a build system.

Without it: plans go stale the moment code learns something.

A Work finding showing a code-side finding flowing back during active work.
Finding flows back
A CLI agent run showing graph-connected source rows while findings flow back from implementation work.
Agent builds from intent

A call nobody owns is a liability nobody holds.

Read the full argument →

Day zero is not a blank graph.

Point Igni at your codebase. The graph builds from real product and code structure. You choose what should guide the work.

Day zero is curation, not data entry.

Charter access

For teams running agents on code that matters.

If this is becoming real inside your engineering team, we'd like to hear from you.

Read Ben's essay →