Every session starts from zero
The agent forgets yesterday's decisions, conventions and bug fixes the moment the session ends.
The Gentle stack for engineering teams
Turn the AI coding agents you already pay for into disciplined engineers.
Gentle-AI is the best practices of the market, and a few beyond it, packed into the agents your team already uses: Claude Code, Cursor, OpenCode, Codex, Pi and a dozen more. You ask in plain language; it picks the right route, remembers, verifies and proves its work. Open source, one binary per machine, no agent lock-in.
- 1
- command to install
- 15+
- agent runtimes
- 5
- open-source tools
Claude CodeOpenCodeCursorCodexGemini CLIVS Code CopilotPiWindsurfKiro IDEQwen CodeKilo CodeKimi CodeAntigravityOpenClawTraeClaude CodeOpenCodeCursorCodexGemini CLIVS Code CopilotPiWindsurfKiro IDEQwen CodeKilo CodeKimi CodeAntigravityOpenClawTrae
Why teams hit a wall
Most agent sessions fail for operational reasons, not model reasons.
Code before requirements
The agent jumps into implementation before anyone agreed what is being built.
Decisions vanish into chat history
Architectural choices live in a scrollback nobody will read again.
One request becomes a wall of changes
A small ask quietly turns into a huge multi-area diff that reviewers cannot digest.
Tests run late, or never
Verification is an afterthought, so "the tests pass" is a claim you have to take on faith.
Skills exist, the model forgets them
Project conventions and skills are written down, but nothing loads them at the right moment.
Organic and natural
Nothing to memorise. Ask for the outcome; the agent finds the route.
Gentle-AI is built so everything is organic and natural. You do not need to know how anything is implemented or which command to type: you describe what you need in plain language, the agent categorises the request and takes the best route to that goal. The workflow adapts to the task, never the other way around.
Say what you want
"Add retries to the upload handler", "why does login flake", "plan the billing rewrite". Plain language, no ceremony, no slash commands.
It categorises the request
A quick fix, an investigation, a substantial feature, a review. The classification decides how much process the job deserves, from the evidence, never from how big it feels.
It takes the best route
Direct inline for the small and understood; one focused explorer or writer when reading has to come first; Spec-Driven Development only when durable artefacts would genuinely reduce ambiguity, and only after you accept it.
No commands to learn, no implementation details to keep in your head. The best practices of the market, and a few beyond it, become the agent's default behaviour.
What every developer gets
The agent remembers, follows your conventions, and picks a working style that fits the task.
A memory that outlives the session
Engram saves decisions, bug fixes and conventions as structured, searchable observations that survive restarts and context compaction.
Skills loaded when the task matches
A curated library of coding skills the agent pulls in on demand, plus your own project and user skills.
A senior-architect persona
A teaching-oriented voice, Gentleman or neutral, or a fully custom persona of your own. It explains the why, not only the how.
The smallest route that works
One to three files: direct. Four or more: one focused explorer or writer. Real ambiguity: it offers Spec-Driven Development. Size alone never adds ceremony.
Spec-Driven Development on demand
Say "use SDD" and the agent explores, proposes, specifies, designs, breaks work into tasks, implements and verifies against what was agreed.
Live documentation through Context7
An MCP server that fetches current framework and library docs, so the agent stops guessing from stale training data.
Model routing and subagents
Per-phase model routing in OpenCode, background subagents in Pi and OpenCode, native sub-agents wherever the runtime supports them.
Guardrails you never have to write
A permissions component with a deny list for ~/.ssh, .env and credential files, backups before every change, and a tool that never installs software silently.
What is behind it
No wrapper, no proxy, no new agent. It configures the runtime you already have.
gentle-ai writes into each agent's native configuration: system prompts, skills, SDD agents, persona files and MCP entries. Memory is an MCP server backed by a single Go binary and a SQLite file. Everything stays on the developer's machine and is snapshotted before each change.
- Your agentClaude Code, Cursor, OpenCode, Codex, Pi…
- gentle-aiwrites persona, skills, SDD agents, MCP entries into the agent's own config
- engramMCP stdio → one Go binary → SQLite + FTS5
- skills · SDD · RDDworkflow, evidence, guardrails
Why it spends fewer tokens of your subscription
Gentle-AI does not save tokens by doing less. It saves them by avoiding wrong work.
The most expensive tokens are the ones spent implementing on a false assumption and redoing it all afterwards. The stack is arranged so that rarely happens:
Explore before editing
So it never implements on top of false assumptions.
Bounded contexts and specialised subagents
Instead of dragging the whole conversation into every step.
Decisions live in artefacts or memory
SDD and OpenSpec artefacts, or Engram, so they are never reconstructed from scratch.
Verify early
Fewer bugs, fewer retries, fewer large rewrites.
The binary owns the deterministic parts
States, routes, hashes, limits and SDD/RDD transitions run in Go, not in the model's reasoning.
Write small, already-understood changes
Less output, smaller diffs, nothing unnecessary.
So do not worry when it explores or verifies for a while: that activity is preventive investment. Reading ten relevant files can be far cheaper than editing three wrong ones and redoing everything afterwards.
The right metric is not "how long did it take before writing?" but:
How much rework, repeated context and unnecessary code did it avoid?
That said, exploring without converging, re-reading the same files or launching subagents without a purpose wastes tokens too. Gentle-AI works because exploration is bounded, evidence-driven and followed by minimal writing.
Engram for your team
One brain for every agent on the team.
Engram is a single Go binary with SQLite and FTS5 full-text search, exposed through CLI, HTTP API, MCP and a TUI. No Node.js, Python or Docker for the core path. Install it once; every agent remembers.
One brain, many agents
Pi, Claude Code, OpenCode, Gemini CLI, Codex, VS Code Copilot, Cursor, Windsurf, Antigravity and any MCP-compatible agent read and write the same memory.
Local first, by design
The SQLite database under ~/.engram is authoritative. Your memory stays on the machine unless you decide to share it.
Token-efficient
Engram stores curated summaries, decisions, prompts and session handoffs instead of a firehose of raw tool calls. Agents search first, then fetch only what matters.
Compaction survival
Before the context resets, the memory protocol pushes a handoff into Engram so the next session recovers the goal, discoveries and next steps.
Project and personal scope
Every observation carries a scope, so teammates' agents find shared project knowledge without wading through personal notes.
Git Sync for portability
Export memory as portable compressed chunks and share it across machines through the repository you already have.
Engram Cloud: shared, project-scoped memory without giving up ownership.
Use Engram Cloud when you want shared, project-scoped memory across machines without giving up local-first ownership. Local SQLite remains authoritative; the cloud is optional replication plus browser visibility for teams and operators.
- Project-scoped replication. Each sync call is tied to one explicit project. There is no implicit "sync everything" mode.
- Self-hosted on your infrastructure. engram cloud serve runs wherever you run containers: an official image on GHCR for linux/amd64 and linux/arm64, ready for Dokploy, Coolify, Portainer or a plain VPS.
- A dashboard for humans. Browser visibility of the organization's knowledge under /dashboard, for operators and teammates who do not live in the terminal.
- Deterministic signals. Clear status and failure reason codes instead of silent drift. Not cloud-only, not a replacement for local SQLite.
Easy, fast, reversible
From a fresh laptop to a disciplined agent in three steps.
brew install gentleman-programming/tap/gentle-ai# one formula on macOS and Linuxgentle-ai# pick your agents, a preset and a persona in the TUIgentle-ai doctor# read-only health report: binaries, state, memory, diskInstall the binary
One Homebrew formula on macOS and Linux. Windows is a fully tested platform that builds from source with Go, never from an unsigned download.
Configure the agents you already use
The TUI detects the agents on the machine and lets each developer pick a preset, the components and a persona. Previous configs are snapshotted before anything is written.
Verify, then keep everything in sync
A read-only health report covers binaries, state, memory reachability and disk space. gentle-ai upgrade and gentle-ai sync refresh the binary and the managed assets together.
Opinionated, on purpose
We ship the opinions so your team stops re-litigating them.
Requirements before code
When ambiguity is real, the agent proposes, specifies and designs before it implements, and you approve at each decision point.
Tests are evidence, not ceremony
Strict TDD mode makes the agent write the test first, watch it fail, then write the minimum code to pass before refactoring.
Reviewable work units
Changes arrive as commits and pull requests sized for a human to read, with tests and docs travelling with the code.
Evidence over narration: RDD, our own design
Receipt-Driven Development is an original design you will not find anywhere else. It freezes the exact bytes under review, picks depth from risk, allows one bounded correction and records an outcome derived from Git, not from the agent's summary.
Determinism wherever it fits
Whatever can be computed instead of reasoned is computed: states, routes, hashes, limits and workflow transitions live in the binary, so the model spends its tokens on judgement.
Our own SDD and TODO, not a template
A custom Spec-Driven Development cycle and a custom TODO discipline, designed around how agents actually fail, and refined in public with the community.
Security by default
Credential files are denied to the agent, nothing is installed silently, and every change to your config is backed up first.
Teach, don't just answer
The persona explains the concept before the code, so the team levels up instead of copy-pasting.
One stack, five tools
Everything an agent needs to behave like a senior engineer.
gentle-ai
The ecosystem configurator
Equips the agents already on each machine with memory, a planning workflow, a curated skill library, MCP tool servers, model routing, a persona and review guardrails. Never installs an agent for you.
View on GitHub →Try gentle-ai
$ brew install gentleman-programming/tap/gentle-aigentle-ai installgentle-ai syncgentle-ai doctorgentle-ai review mode enable|disable|status
engram
Persistent memory for every agent
One Go binary with SQLite and full-text search, exposed through CLI, HTTP API, MCP and a TUI. Local first; Git Sync shares memory across machines and Engram Cloud adds optional project-scoped replication with a browser dashboard.
View on GitHub →Try engram
$ brew install gentleman-programming/tap/engramengram mcpengram search <query>engram save <title> <msg>engram doctor
gentle-pi
Pi as a controlled development harness
Spec-Driven Development, focused subagents, strict TDD evidence, reviewable work units and safety guards on top of the Pi coding agent, with review evidence derived from Git instead of agent narration.
View on GitHub →Try gentle-pi
$ pi install npm:gentle-pi@latestpipi listpi updatepi configpi auth
gga
AI code review before the commit leaves the machine
Gentleman Guardian Angel runs a provider-agnostic review as a git pre-commit hook using whichever provider you already have: Claude, Gemini, Codex, OpenCode or Ollama.
View on GitHub →Try gga
$ brew install gentleman-programming/tap/ggagga installgga rungga configgga cache status
Gentleman.Dots
The same environment on every desk
A single TUI installer for Neovim, Fish, Zsh or Nushell, Tmux, Zellij or Herdr, Ghostty, Kitty, WezTerm or Alacritty and the Starship prompt, on macOS, Linux, WSL and Termux. Includes an RPG-style Vim trainer.
View on GitHub →Try Gentleman.Dots
$ brew install Gentleman-Programming/tap/gentleman-dotsgentleman-dotsgentleman-dots --dry-rungentleman-dots --non-interactive --shell=fish
FAQ
The questions engineering leads ask first.
Does Gentle-AI install AI agents for us?
No. It configures agent runtimes that are already present on the machine. If you select an agent it cannot detect, it refuses and prints the exact command you would run yourself. It never installs software silently.
Which agents does it support?
Full delegation: Claude Code, OpenCode, Kilo Code, Gemini CLI, Cursor, VS Code Copilot, Kimi Code, Kiro IDE and Qwen Code. Pi is package-managed through gentle-pi. Solo-agent support covers Codex, Windsurf, Antigravity, OpenClaw and Trae, and Hermes is detect-only.
Where does our memory live, and who can see it?
Locally by default, in a SQLite database under ~/.engram that stays authoritative. Git Sync exports portable compressed chunks you control, and Engram Cloud is optional, self-hosted, project-scoped replication you enrol per project. Gentle-AI itself does not send your code anywhere; your agents keep talking to their own providers as before.
Is the evidence-based review step mandatory?
No. Receipt-Driven Development is opt-in and off by default. Nothing happens until someone runs gentle-ai review mode enable --scope global, and its outcome is informational: it records evidence, it does not block a commit or a release.
Will it slow down small tasks with process?
No. The agent picks the smallest route that gets to the outcome: understanding one to three files means it just does the work. Size never selects the heavier Spec-Driven route on its own; only an explicit request or an accepted proposal does.
Why is it so opinionated?
Because most agent sessions fail for operational reasons, not model reasons. The stack ships a working set of opinions (requirements first, tests as evidence, reviewable work units, security defaults) so a team stops re-litigating them, while the Custom preset still lets you keep your own persona and settings.
How do I make the case to my product leaders?
Lead with cost and risk, not with tooling. Cost: the stack saves tokens by avoiding wrong work (explore before editing, bounded contexts, decisions kept in memory, early verification), so the subscription you already pay for produces fewer rewrites. Risk: evidence-based review replaces "the tests pass" with an outcome derived from Git, and security defaults keep credential files away from the agent. Consistency: every developer's agent follows the same conventions, so onboarding and hand-offs stop depending on who configured what. And the decision is cheap to reverse: it is open source, there is no lock-in, it never installs agents for you, every config change is backed up, and a pilot is one command per machine. Propose a two-week pilot on one team with a measurable question: how much rework, repeated context and review time did it remove?
What do full delegation and solo-agent support mean?
It describes what the agent runtime itself can do, because Gentle-AI configures each agent through its own native features. Full delegation means the runtime can hand work to focused sub-agents (Claude Code's Task tool, Cursor's or Kiro's native subagents, OpenCode's multi-mode overlay): the main conversation stays a thin coordinator while an explorer reads, a writer implements and reviewers check, each with only the context it needs, which is where most of the token savings and the review depth come from. Solo-agent means the runtime runs everything in one conversation (Codex, Windsurf, Antigravity, OpenClaw, Trae): you still get the persona, skills, memory, workflow and guardrails, but routing happens inside a single context, so the benefits of bounded contexts are smaller. Detect-only (Hermes) means Gentle-AI recognises the agent but you finish the setup by hand.
Is it open source, and under which license?
Yes. gentle-ai, engram, gentle-pi and Gentleman Guardian Angel are MIT licensed; Gentleman.Dots is Apache-2.0. The gentle-pi name and logo are trademarks, which the license does not cover.
Does it run on Windows?
Gentle-AI is fully tested on Windows and installs from source with Go 1.25.10 or newer; there is no unsigned binary download by design. Gentleman.Dots targets Windows through WSL.
How do we roll it out to a team?
Everyone installs the same binary and picks the same preset, so every machine gets the same baseline. Engram observations carry a project or personal scope for searching; note that scope is a search filter, not a privacy boundary: enrolling a project for sync shares both, so keep personal notes in a separate project.
What does Engram Cloud add, and do we have to use it?
Nothing changes unless you enrol a project. Engram Cloud is a self-hosted runtime (engram cloud serve, official image on GHCR) that replicates one explicit project at a time and gives the team a browser dashboard. Local SQLite stays authoritative, and there is no cloud-only mode.
How do we update, and what if something breaks?
Run gentle-ai upgrade followed by gentle-ai sync. Every install, sync and upgrade snapshots your configuration; backups are compressed, deduplicated and pruned to the five most recent, and you can pin the ones that matter. gentle-ai doctor is a read-only report you can run any time.
Give your agents a brain and a process.
One command per machine. Open source. Nothing to unlearn if you stop using it.