Sentigent gives Claude Code and Claude Cowork what they're missing: a company to serve, a plan to finish, and a memory that learns from real results — so your team's AI ships verified work instead of guesses.
pip install sentigent
# 1 · plug it into Claude Code (or any AI coding agent) pip install sentigent sentigent init # MCP + hooks, one time # 2 · keep coding like normal. now your agent… ✓ remembers the plan across sessions ✓ keeps going at a blocker instead of stopping to ask ✓ still stops for the dangerous calls # force-push · prod · secrets # when a run ends — one honest number, not a vibe FAP 0.88 # how far it got with no help
The harness frontier AI labs build for their own agents — company knowledge, an accountable plan, a self that learns — given to any small team, on top of Claude Code & Cowork. They already act in your real tools (Gmail · Drive · Slack · Stripe…) over MCP; Sentigent supplies the three things that turn a tool into a colleague, then learns from every outcome. One MCP server, useful from every Claude surface.
North-star, mission, brand, policy, playbooks as one shared, drift-free knowledge bundle (OKF). The worker stays on-mission and in-policy.
A goal becomes a phased, verified plan the loop drives to done across sessions — reported as FAP, one honest number.
A shadow agent per teammate that learns their judgment and earns autonomy from outcomes — shadow → suggest → draft → own the loop.
# the whole picture — one loop you set direction ──▶ SENTIGENT supplies ORGANIZATION · PROJECT · AGENT ──▶ CLAUDE CODE / COWORK acts (plans · edits · sends · files, via MCP) ▲ │ └──────────────── outcome graded ◀──────────────────────────┘ record_outcome → the brain learns → autonomy earned, drift caught legend: ✅ verified, no help ○ escalated to you ❌ blocked by policy (rolled up as FAP)
The execution layer is commoditizing — that's good for us. What compounds with use is the layer we own: a company's knowledge, a verified plan, an employee that learns. Full direction → PRODUCT-DIRECTION.md
Honest about enforcement: on Claude Code, Sentigent can block a risky action before it runs (policy, not a model's guess). On Claude Cowork, it brings your company's knowledge and records every outcome today — policy-level action-blocking is rolling out as we extend enforcement across surfaces.
Three things a raw loop can't do on its own — and the reason Sentigent doesn't need babysitting and won't drive off a cliff.
Sentigent learns your push-vs-ask judgment from the blockers you answer, writes it back as a steering file your agent reads — and enforces the practices you pick (tests before a commit, review before a merge) at the moment they matter. The more it sees, the less it asks.
# pick the practices to enforce — off · warn · block sentigent practices add "Run the tests before committing" sentigent practices enforce 1 block # commit with no test run this session → git commit -m "wip" ⛔ blocked # practice not met · run tests, or drop it to warn
Every step carries its own done-criteria, and nothing counts until it verifies. When the run ends you get FAP — Faithful Autonomous Progress — one honest number, not a made-up confidence score.
# each step has its own gate; fail → self-repair retry steps: - write parser verify: pytest tests/test_parse.py - add tests verify: pytest -q - wire the CLI verify: sentigent --help sentigent loop receipt FAP = verified-with-no-help ÷ total # real, per run
A hard wall the loop can never auto-clear. Force-push, production databases,
secrets, rm -rf, anything that leaves your machine — those always stop and ask you. Humans set intent; the agent acts; you gate the rest.
# never auto-cleared — always escalates to a human escalate: - force_push - prod_db_write - secret_access - rm_rf - external_send # the loop pauses, asks you, and remembers your answer.
State lives on disk in ~/.sentigent/loops/. Kill the process, hit a usage limit, close the
laptop — a fresh agent reloads the plan and its position and keeps going.
Goal + steps + per-step done-criteria, stored durably.
A fresh agent runs the next step with full context.
Re-runs your done-criteria. Fail → self-repair retry.
Go or ask — as you would. Dangerous calls always ask.
Reloads plan + position from disk. Survives restarts.
Hand it a vision and a plan; it works lap after lap until the done-criteria are met.
The plan and its position are on disk, so a context limit or crash is just a pause.
Each question you answer becomes a precedent — so next time it answers it itself.
Each layer owns a different question. Together they answer the only one that matters at a blocker: keep going, or stop and ask?
All three layers run on your machine for free, forever. If a team would rather not self-host the org control plane, a managed version will come later — but everything works free today.
The whole thing — nothing held back.
For teams who'd rather not run the org control plane themselves.
# 1 — install pip install sentigent # 2 — wire it into Claude Code / any AI coding agent sentigent init # now seed a loop and let it run sentigent loop start --goal "…" --steps "…" --verify "pytest -q" sentigent loop drive <loop_id> --execute