Soar AI Labs, Inc.

Sept 08, 2025

At every inflection in developer tooling, the interface changed first.

Diffs made history navigable. Hosted repos made collaboration routine. Code review made quality a habit.

What hasn’t changed is how we steer the system. Git still asks humans to juggle intent, context, and ceremony across commands, tabs, and tribal rules. It’s precise—but it isn’t anticipatory.

Our thesis

Version control should be invisble and intent-first. The tool should understand what you’re trying to do, predict the next two steps, and execute safely with your approval. That requires a context engine for codebases—not another prompt box or dashboard.

Inspired by the frontier of interface work outlined in Sequoia’s backing of Zed, we believe the real leap won’t come from yet another model alone, but from systems that shape interaction: perception of state, memory over time, and trajectories that align with developer intent.

The Context Engine

We’re rebuilding version control around context, not just commands.

• Memory layer over your codebases
  A persistent memory layer sits atop each repo, ingesting commits, PRs, issues, topology, and team conventions. It encodes intent, style, and workflow norms per user and per team.
• Multi‑agent orchestration
  On top of this memory, coordinated agents plan, verify, and execute actions. One agent reasons about branch strategy, another about semantic history, another about CI/review gates—then a planner composes a safe, auditable trajectory.
• Preference‑ and behavior‑aware prediction
  The memory layer learns how you work. It doesn’t just recall facts; it models your patterns and project rituals to predict the next action you’re likely to take—two steps ahead—then proposes it with diffs, rationale, and undo.
• From context to decisions
  With rich state and trajectories, Kite can recommend: when to rebase vs. merge, how to split commits, which conflicts are safe to auto‑resolve, and what a clean PR looks like—before you ask.

Research track: effectively unlimited context

Token limits constrain real understanding. Our next milestone extends the memory layer into an “unlimited” context interface for the model:

• Hierarchical retrieval that preserves global structure while streaming only decision‑critical slices
• State compaction that maintains logical invariants, not just text chunks
• Deterministic citations back to source (commits/PRs/files) for trust and review

It may sound out of reach with today’s raw token windows, but our approach avoids the usual jank. By separating durable memory from ephemeral prompts—and binding every generation to verifiable citations—we get practical, near‑unbounded context without sacrificing speed or safety.

Why this matters

• Anticipation over reaction: the terminal proposes your next two steps, not just runs what you type.
• Consistency at scale: team conventions become enforceable, not aspirational.
• Trust by construction: previews, diffs, and one‑command undo keep humans in control.

Kite is the first expression of this system. The context engine powers its plan‑then‑act workflows today, and will unlock predictive, preference‑aware automation next.

Always two steps ahead

Instead of reacting to commands, the terminal should propose the plan: here’s the rebase, the conflicts we’ll resolve, the commits we’ll split, and the PR we’ll open—with diffs you can trust and one‑command undo. Think of it as navigation for version control: clear route, live conditions, easy exits.

Kite is our first step

Kite is the developer-facing assistant that sits on top of this engine.

What Kite does today

• Natural language to precise Git: “rebase feature/payments on main and open a PR with a summary” → previewed commands, then execute.
• Conflict intelligence: a fine‑tuned model proposes safe, explainable resolutions with side‑by‑side diffs and instant rollback.
• Semantic commit splitting: turns sprawling changes into coherent commits with clear messages and scopes.
• Retrieval‑augmented repo chat: ask “why was auth refactored?” or “what changed since v1.3?” with citations to commits, PRs, and reviews.
• Plan‑then‑act safety: dry‑runs by default, temp branches for every action, one‑line undo.

What comes next

• Live context engine in the terminal: learn your repo’s topology, your team’s rituals, and predict the next two steps before you ask.
• Cross‑tool memory: carry intent across editor, CLI, CI, and code review without new tabs or new silos.
• Policy‑aware automation: enforce conventions automatically—human‑readable history by default.

Principles

• Local by default: your code stays with you. Cloud acceleration is opt‑in and encrypted.
• Explainable automation: every proposed action has a rationale, a diff, and an undo path.
• Augment, don’t abstract: keep Git’s guarantees, reduce its ceremony.

About the lab

We’re an applied research and product group focused on intent‑aware developer interfaces. Our work spans long‑lived context, trajectory prediction for code workflows, and semantic version control. We prototype in the open and harden through real usage.

Open source, with a managed path

Kite’s core is open. Self‑host if you prefer. Our freemium managed offering adds faster models, shared team memory, and zero‑ops indexing.

If you’re exploring adjacent problems—human‑AI collaboration for dev tools, long‑term repo memory, multi‑agent orchestration for code, or prediction of developer trajectories—we’d love to compare notes.

Get involved

• Install: Amaan should remember to add this command here
• GitHub: star, file issues, contribute
• Talk to us: our final email goes here
• Community: Docs • Roadmap • Discord

Ship with intent. Let the terminal be two steps ahead. Our first step is Kite.