Gentle Ai

9.1K stars
MIT
Active this week
Last commit today

Last verified Nov 14, 2026

Power your AI coding agents with persistent memory, structured workflow, and evidence-based review across 17 runtimes.

Visit website GitHub9.1K

Read the full breakdownWho it is for, how it works, trade-offs, the quick start and the FAQ

who it's for

Who Gentle Ai is for#

Developers using Claude Code, Cursor, or Codex every day

Gentle AI adds the memory layer that commercial agents lack out of the box. Daily users gain session continuity (Engram pulls prior decisions before asking for them), proportional workflow (ODD routes small work inline and keeps large work recoverable), and evidence-bound review (RDD freezes the change before assessing it).

Skip if:

If your workflow is exploratory and you treat every session as a deliberate fresh start, the memory layer adds overhead without benefit. Gentle AI is for teams that want to build on accumulated project context, not reset it.

Engineering teams rolling out AI coding tools to multiple developers

Gentle AI installs one binary per machine via Homebrew and configures each developer's existing agents with a shared workflow and memory layer. Developers on different agents (some on Claude Code, others on VS Code Copilot) get the same ODD workflow and Engram memory without needing to standardize on a single agent.

Skip if:

If your team is two or fewer developers with already-established prompting conventions, the overhead of a structured workflow may not add value over direct agent use.

Teams where code review and change traceability matter

RDD freezes the exact change before review and assigns review depth by risk tier (passive, medium, high with 4R lenses: Risk, Resilience, Readability, Reliability). For teams that need auditable evidence of what was reviewed, this provides a structured trail without changing the commit or push workflow.

Skip if:

If your existing review process is entirely human-gated with no AI review at any step, adding RDD may duplicate effort. It adds most value when AI review is part of the workflow and you want proportionality rather than a fixed-depth review on every change.

Open source contributors watching API spend on coding agents

The benchmarked routing rules reduced a 3-line bug from $0.339 to $0.105 by running inline instead of delegating to subagents. For contributors using pay-per-token models like Codex or Claude, the workflow's proportionality rules can materially reduce session costs on the tasks that routing most helps.

Skip if:

If you are on a fixed-price subscription plan (like GitHub Copilot or Cursor's flat-rate tier), the cost argument is less compelling. The workflow and memory benefits still apply regardless of billing model.

the problem

The problem it solves#

Every AI coding session starts empty. When the context window fills or a new session begins, the agent forgets every decision, convention, and recurring bug pattern your team has established. Developers re-explain the same constraints, re-describe the same architecture, and watch the agent make the same mistakes in every session. At scale, this erodes trust and creates unpredictable output quality across the team.

The second pain is proportionality. Without a workflow layer, an AI coding agent treats a one-line bug fix and a multi-file refactor the same way: by guessing the approach, delegating aggressively, and generating output sized for the task as the model understands it rather than as the developer specified. Code review happens after the fact, with no guarantee that the reviewed version is the same code that was committed.

how Gentle Ai solves it

How it solves it#

Persistent memory across sessions with Engram

Engram is a local Go binary that stores project decisions, conventions, and bug fixes in SQLite with full-text search. When a new session starts, the agent reads Engram before asking you, so context accumulates instead of resetting each morning. Git Sync shares memory across machines; optional Engram Cloud adds self-hosted, project-scoped replication with a dashboard.

Structured workflow that keeps small changes small

Organic Driven Development (ODD) is a seven-step workflow from authorize to close. Small changes run inline with no planning overhead; larger work gets a feature document in the developer's exact words, with small commits and progress tracked so work can resume after a session ends. Tasks are sized by risk and resumability, never by file count.

Risk-proportional code review frozen to the exact change

Receipt-Driven Development (RDD) freezes the change before any review reads it, so the evidence belongs to the exact version being committed. Review depth is proportional to risk: passive changes get a structural readback; medium-risk changes get one focused lens; high-risk changes get the 4R review (Risk, Resilience, Readability, Reliability). Commit, push, and release remain the developer's decision.

Works with 17 AI coding agents, no lock-in

Gentle AI configures Pi, OpenCode, Claude Code, Codex, Cursor, VS Code Copilot, Gemini CLI, and ten more agents using each agent's native capabilities. Features available (such as delegation and RDD review) differ by agent. Installing Gentle AI does not install an agent; it configures the agents already on the machine.

Subagent delegation only when there is a named reason

Delegation to subagents triggers on four named conditions: exploration that exceeds one inline batch, two genuinely independent units of work, a long session handing off its next bounded unit to a fresh worker, or a high-risk change requiring an independent verifier. File count, task size, and model cost never decide the route. The README documents benchmark results: a 3-line bug that previously cost $0.339 runs inline at $0.105.

Security deny-list and snapshotted config backups

Gentle AI blocks agent access to ~/.ssh, .env, and credential files by default via a security deny-list. Every write to agent configuration is snapshotted before the change is applied, so a failed or unintended configuration update is recoverable from the most recent backup.

strengths · trade-offs

Strengths and trade-offs#

Strengths

MIT licensed with no cloud dependency or agent lock-inThe configurator is MIT licensed and runs as a single Go binary on macOS, Linux, and Windows. Memory (Engram) is stored locally in SQLite; no cloud account, no analytics pipeline, and no dependency on the agents it configures. Teams can keep everything on their own infrastructure with no vendor relationship beyond the GitHub repository.
Agent-agnostic: adds the same workflow to 17 runtimesGentle AI adds memory, workflow, and review to the agents developers already pay for or already use. Switching from one supported agent to another does not require re-learning the workflow layer, and accumulated memory stays accessible to all 17 integrations via Engram.
Review is frozen to the exact candidate, not the working treeRDD freezes the exact change before any review reads it. The review evidence belongs to the specific version being committed, not whatever the working directory looked like a moment later. The README describes this as preventing review drift: the evidence is bound to the candidate rather than the model's recollection.
Delegation rules derived from published benchmarksThe trigger rules for subagent delegation came from benchmarks on real tasks. A 3-line bug dropped from 335s and $0.339 to 77s and $0.105 by routing inline; a data migration with high risk was accepted on the first review round instead of requiring a feedback cycle. Sources are linked in the README (gentle-shell#1723 and #1794).

Trade-offs

-Windows install requires a manual Go source buildOn macOS and Linux, installation is one Homebrew command. On Windows, there is no binary download by policy (the maker explicitly states builds are from source to avoid unsigned downloads); developers must have Go 1.25.10+, Node.js 18+, and Git 2.38+ on the PATH. Teams that cannot build from source on Windows will need to wait for the project to ship a signed installer.
-Memory and workflow depth varies by agent integrationGentle AI configures all 17 supported runtimes, but available features such as delegation and Receipt-Driven Development review differ by agent because the tool uses each agent's native capabilities. The agents.md document in the repository lists which capabilities each integration exposes. Teams relying on RDD review or multi-agent delegation should check their specific agent's support level before adopting.
-367 open issues across a rapidly growing projectAs of this writing the repository has 367 open issues. The project grew to over 9,000 stars in roughly nine months, and the open issue count reflects both active community engagement and unresolved bug reports. Users may encounter known issues, particularly on integrations that receive less active development. Filtering issues by your specific agent before adopting is worthwhile.

versus alternatives

Gentle Ai vs alternatives#

Gentle AI vs GitHub Copilot

Both tools assist AI-based development, but at different layers. GitHub Copilot is a proprietary, subscription-based inline code assistant tied to a GitHub account; Gentle AI is an open source configurator that adds memory, workflow, and proportional review to the agents you already use, including Copilot itself via its VS Code Copilot integration.

Feature	Gentle AI	GitHub Copilot
License	MIT	Proprietary
Self-hosting	Yes (local binary)	No
Persistent memory	Yes (Engram, local SQLite)	Session context only
Structured workflow	Yes (ODD, 7-step)	No
Risk-proportional review	Yes (RDD)	No
Agent support	17 runtimes (including Copilot)	Copilot only
Pricing	Free	Paid subscription

Gentle AI is the better choice when you need memory that survives session resets, a workflow that keeps small changes lightweight and large changes recoverable, and evidence-bound review proportional to change risk. It runs alongside Copilot: adopting Gentle AI does not require canceling an existing subscription.

GitHub Copilot is the better choice when you want deep IDE-integrated inline code completion with minimal setup. Its ghost-text completion, IDE integration across VS Code and JetBrains, and GitHub-side features (pull request summaries, code scanning suggestions) are outside what Gentle AI provides.

Gentle AI vs Cursor

Cursor is a paid AI coding IDE with proprietary model access; its workflow and context features are specific to the Cursor environment. Gentle AI adds the same memory and workflow layer to Cursor as it does to any of the other 16 integrations, making it useful for teams that mix Cursor users with users of other agents.

Feature	Gentle AI	Cursor
License	MIT	Proprietary
Agent lock-in	None (17 runtimes)	Cursor-specific
Persistent memory	Local SQLite (Engram)	Session context only
Pricing	Free	Paid subscription

Gentle AI is the better choice when your team uses multiple agents and needs consistent workflow and memory across all of them. Cursor is the better choice for developers who want an all-in-one IDE experience with built-in model access and no terminal-side configuration.

install · quick start

Quick start#

bash

Install on macOS or Linux with the Homebrew tap; Windows requires a source build with Go.
```bash
brew install gentleman-programming/tap/gentle-ai
```

tech stack · detected from GitHub

What it's built on#

Languages: GoJavaScriptPython

frequently asked

FAQ#

Does Gentle AI install its own AI model or agent?

No. Gentle AI configures the AI coding agents you already have installed (Claude Code, Cursor, Codex, and 14 others). It does not install an agent, subscribe to a model API, or proxy your requests. Your existing agent and API key stay in place; Gentle AI adds memory, workflow, and review on top.

What is Engram and does it store code in the cloud?

Engram is a local Go binary that stores project memory in SQLite on your machine. By default, nothing leaves your machine. Git Sync optionally shares memory across your own machines via your existing Git remote. Engram Cloud, if you use it, is self-hosted; there is no Gentle AI-operated cloud service receiving your code or memory.

Does Gentle AI work with GitHub Copilot in VS Code?

Yes. VS Code Copilot is one of the 17 supported agent integrations. Available features (memory, workflow, delegation, and RDD review) differ by agent because Gentle AI uses each agent's native capabilities. The agents.md file in the repository documents which features each integration supports.

How do I install Gentle AI on Windows?

Windows does not have a binary download; builds are from source only, which the maker describes as a deliberate security policy (no unsigned downloads). You need Node.js 18+, Git 2.38+, and Go 1.25.10+ or later. After building, run gentle-ai to select and configure your agents. The Windows steps are in the repository README.

Can I turn off the automatic code review (RDD)?

Yes. Receipt-Driven Development is on by default and opt-out. Run gentle-ai review mode disable to turn it off. The README notes that explicit global or clone-local OFF choices remain OFF, and that review is proportionate: an automatic review only triggers for a high-risk candidate, so low-risk changes do not incur a review by default.

also worth a look

Similar open-source tools#

Nuphos

Featured

Alternative toConductor

Agent workspace for teams running Claude Code or Codex

529 GitHub stars
Licence Apache-2.0

REA (Reverse Engineer Anything)

Featured

Alternative toRevEng.AI

AI-powered reverse engineering for binaries, apps, and assemblies.

450,612 GitHub stars
Licence MIT

rakazo

Featured

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

7,869 GitHub stars
Licence Apache-2.0

Agent Reach

Featured

Alternative toFirecrawl

Give any AI agent internet access, free and local

111,579 GitHub stars
Licence MIT

Hermes Agent

Featured

Alternative toGrok Bot

Self-hosted AI agent: persistent memory, multi-channel chat, model choice.

262,494 GitHub stars
Licence MIT

Rerun

Alternative toFoxglove

Log, visualize, and query multimodal physical AI data.

11,791 GitHub stars
Licence Apache-2.0

by category

Open source tools in these categories#

533

12,987 GitHub stars
Licence AGPL-3.0
#Email

rakazo

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

7,869 GitHub stars
Licence Apache-2.0
#AI Agents

SnitchFeed

Live monitoring on LinkedIn, X, Reddit & more. Agentic social listening for startups.

Marketing & Growth

Advertise your product

The projects we add and every new guide. Free, unsubscribe any time.

Find open source alternatives to paid software

Gentle AI vs GitHub Copilot

Feature	Gentle AI	GitHub Copilot
License	MIT	Proprietary
Self-hosting	Yes (local binary)	No
Persistent memory	Yes (Engram, local SQLite)	Session context only
Structured workflow	Yes (ODD, 7-step)	No
Risk-proportional review	Yes (RDD)	No
Agent support	17 runtimes (including Copilot)	Copilot only
Pricing	Free	Paid subscription

Gentle AI vs Cursor

Feature	Gentle AI	Cursor
License	MIT	Proprietary
Agent lock-in	None (17 runtimes)	Cursor-specific
Persistent memory	Local SQLite (Engram)	Session context only
Pricing	Free	Paid subscription

Who Gentle Ai is for#

Developers using Claude Code, Cursor, or Codex every day

Skip if:

Engineering teams rolling out AI coding tools to multiple developers

Skip if:

Teams where code review and change traceability matter

Skip if:

Open source contributors watching API spend on coding agents

Skip if:

The problem it solves#

How it solves it#

Persistent memory across sessions with Engram

Structured workflow that keeps small changes small

Risk-proportional code review frozen to the exact change

Works with 17 AI coding agents, no lock-in

Subagent delegation only when there is a named reason

Security deny-list and snapshotted config backups

Strengths and trade-offs#

Strengths

Trade-offs

Gentle Ai vs alternatives#

Gentle AI vs GitHub Copilot

Gentle AI vs Cursor

Quick start#

What it's built on#

FAQ#

Similar open-source tools#

Open source tools in these categories#

AI & Machine Learning

Developer Tools

Find open source alternatives to paid software

Who Gentle Ai is for#

Developers using Claude Code, Cursor, or Codex every day

Skip if:

Engineering teams rolling out AI coding tools to multiple developers

Skip if:

Teams where code review and change traceability matter

Skip if:

Open source contributors watching API spend on coding agents

Skip if:

The problem it solves#

How it solves it#

Persistent memory across sessions with Engram

Structured workflow that keeps small changes small

Risk-proportional code review frozen to the exact change

Works with 17 AI coding agents, no lock-in

Subagent delegation only when there is a named reason

Security deny-list and snapshotted config backups

Strengths and trade-offs#

Strengths

Trade-offs

Gentle Ai vs alternatives#

Gentle AI vs GitHub Copilot

Gentle AI vs Cursor

Quick start#

What it's built on#

FAQ#

Similar open-source tools#

Open source tools in these categories#

AI & Machine Learning

Developer Tools

Find open source alternatives to paid software