The governed layer above your coding agents
Describe the outcome.
TaskForce runs
the delivery.
Claude Code, Cursor or Copilot writes the code. TaskForce turns the outcome into the spec, the plan and the prompt it runs. A human approves every step, and the reasons are remembered.
| Run | Step | Owner | Status |
|---|---|---|---|
| CP-12Let customers export their invoicesAwaiting your approval | Awaiting your approval | ||
| CP-14Add SSO with OktaPR opened | PR opened | ||
| CP-09Rate-limit the public APIApproved | Approved | ||
| CP-17Fix the flaky billing testAssigned | Assigned | ||
| CP-05Upgrade the API to Node 22Shipped | Shipped |
Works with the tools your engineers already trust
GitHub
Linear
Slack
Notion
Figma
AWS
Datadog- Claude
The problem
Teams don’t lose time building. They lose it transferring context.
Most software delivery moves the same way: an intention is passed from hand to hand until something ships. At each handoff the reason behind a decision gets thinner, and the reason is the part nobody writes down.
The work isn’t the problem. The transfer is.
TaskForce keeps the context in one governed run, written down once and carried from outcome to ship.
Why it's different
A delivery system, not an assistant
Most AI tools optimize execution. TaskForce optimizes the system that decides what gets executed: one platform where planning, memory, the governed run and the audit trail already know about each other, instead of four tools you wire together.
Agents without context become assistants.
Context without execution becomes documentation.
TaskForce connects both.
- Frame the outcome & DoD
- Draft spec + acceptance criteria
- Hand to a human to approve
Plan
· Agent runtimeAgents draft each checkpoint: the vision, the spec, the architecture.
Remember
· TaskForce MemoryLinks every decision, constraint and trade-off, with the reason attached.
Running · Spec
Execute
· Workflow engineThe governed run: checkpoints, approvals and assignment, all on the record.
TaskForce Memory
powered by Brain OSGit remembers what changed. TaskForce remembers why.
Not a search box over your docs, but a map of why. TaskForce Memory links the decisions, constraints and trade-offs behind the system, and how they connect. Every run reads why the system is the way it is, and writes its own decisions back.
So a senior stops re-explaining the system for two hours, and the next run, or the next hire, never starts from a blank page.
Inside TaskForce MemoryThe payoff is daily: fewer meetings, fewer half-written tickets, less context re-explained, and agents that already understand your system.
What ships today
Not a someday demo. This part is already live.
The full governed run is the direction. But the core act works today, grounded in your memory and running on the models you choose.
Turn an issue into a spec and a prompt
Point TaskForce at an issue. It drafts the product spec, a ready-to-run prompt for your coding agent and the breakdown, checked against your past decisions. You approve, and the decision is saved to Memory.
- As a buyer, I can pay with a saved card
- AC: idempotent on double-submit
- Prompt: add idempotency keys
Ask your project what to do next
The decision board reads your real project (what's open, what's late, what's due this week) and proposes your next three priorities, with the reasoning. One click turns a priority into an issue.
Smart Assign: the right task to the right person, with the reason
TaskForce reads each unassigned issue and every teammate's skills, workload and availability, then proposes who should own what. You review the recommendations, then assign the whole batch.
- Skills-aware. Matches the work to who's actually good at it, not who's free first.
- Workload-balanced. Reads current load and availability so nobody gets buried.
- One click, whole batch. Assign every unassigned issue at once, and uncheck the ones to keep.
Hosted in the cloud, or self-hosted on local models at zero model cost.
The run
Watch one outcome become a shipped change
A delivery is a sequence of decisions, not a single prompt. TaskForce makes each one explicit: an agent drafts it, a human signs it off, and the run moves on.
Illustrative: each step is an agent draft that a human approves. The seven real checkpoints are detailed below.
Every step is attributable
Each checkpoint names what produced it and the model it ran on.
Nothing advances without you
Each checkpoint waits for a human, which is exactly what lets you hand agents more, not less.
Rejections carry your comment
Send a step back with a note and it comes into the next attempt.
Drafting a spec and the breakdown ship today; the full seven-checkpoint run is Planned.
Seven checkpoints. Seven artifacts. One accountable chain.
Not a black box that returns a pull request, but a sequence of artifacts, each one attributable and each one refusable.Show the seven checkpointsHide the checkpoints
| Checkpoint | Produced by | What lands in your workspace | What you decide |
|---|---|---|---|
| 01VisionPlanned | CPO agent | One page: the problem, who has it, what « done » looks like. | Approve the framing, or reframe it before anything is built on top. |
| 02Product specPlanned | CPO agent | Stories with acceptance criteria, and the edge cases nobody asked about. | Approve, or send it back with what is missing. |
| 03ArchitecturePlanned | CTO agent | The proposed approach, and the option that was rejected with the reason. | Approve the trade-off. This is the decision that is expensive to reverse later. |
| 04API contractPlanned | CTO agent | Endpoints, payloads and error cases, written against your existing conventions. | Approve or amend. Downstream steps are generated from what you sign here. |
| 05BreakdownLive | COO agent | Issues, sized and ordered, each linked back to the line of spec it came from. | Approve it, then Smart Assign routes each issue to a person. |
| 06ImplementationLive | Your coding agent | A branch. TaskForce hands over the context and stays out of the way. | Your normal code review. We do not replace it. |
| 07QA & deployBeta | COO agent | A checklist derived from the acceptance criteria you approved in step two. | Sign off. The whole chain is in the audit trail. |
Adaptive by design
A bug fix doesn't need a strategy phase; a migration doesn't take the same path as a feature launch. The run adapts to the decision being made. It just never skips the approval.
Built to survive a security review
AI in the delivery path raises exactly the questions you would expect. We would rather answer them on a page than in a questionnaire.
Security & data
- Self-hosting, your network
- Encryption in transit & at rest
- Secrets out of the codebase
- No training on your data
Access & controls
- SSO / SAML via Keycloak
- Roles & permissions
- A human sign-off at each checkpoint
- Per-project access
Built for SOC 2 readiness, GDPR-ready by architecture, with a security roadmap you can read on the trust center.
- Approved · Architecture · Postgres over MongoDBInès · CTO2m
- Sent back · API contract · error casesInès · CTO6m
- Approved · Product spec · CheckoutThéo · CPO14m
- Model call · Breakdown draftedCOO agent21m
- Approved · Vision · Checkout redesignThéo · CPO34m
- Assigned · Implementation → MayaLéo · COO42m
- Model call · Spec draftedCPO agent55m
- Approved · Breakdown · 8 issuesLéo · COO1h
Every run attributable, every approval recorded, every model call logged. Exportable to your SIEM.
Built for engineering teams first
TaskForce is engineering-first, and we don’t hide it. But a governed run with a sign-off at each step isn’t specific to code. It expands to every team that ships reviewed work.
Ship a feature
Spec, break down, hand code to an agent, review the PR.
Triage the backlog
Issues sized and routed to the right dev, or to an agent.
Reproduce a bug
A clean repro and a failing test before anyone opens the file.
Engineering is the wedge, not the ceiling. The memory that keeps one run’s context is the same knowledge an organization loses in meetings, in chat and in people’s heads. The roadmap is public, so hold us to it.
See the public roadmapFAQ
Frequently asked questions
- What is TaskForce?
- TaskForce is an AI delivery operating system. You describe an outcome, scoped agents plan and draft each step, and a human approves every checkpoint before anything ships. It sits on top of the board and repository you already use.
- How is TaskForce different from Cursor, Copilot or Devin?
- Those tools help write code inside the editor. TaskForce runs the delivery around the code: it turns an intent into reviewable checkpoints, keeps the context of every decision, and routes work to the right person or agent. It orchestrates the flow rather than autocompleting one file.
- Does a human stay in control?
- Yes. Every step waits for a human sign off at its checkpoint. Agents draft and propose, they do not ship on their own, and you keep an auditable trail of what was decided.
- Can the AI models run on our own hardware?
- Yes. TaskForce can use hosted providers or models running on your own infrastructure, so sensitive work does not have to leave your environment.
- What can TaskForce do today, and what is planned?
- Collaboration, Smart Assign and analytics are live. Approvals, TaskForce Memory and integrations are in beta. Handing an issue to Claude Code through a local runner on your own machine is in beta, and you set it up yourself. Deeper orchestration and agent roles are on the public roadmap. We label maturity honestly rather than promising everything at once.
- Is there a free plan?
- Yes. You can start for free, with paid tiers for teams that need more. Members are unlimited on every plan.
Start with one run
Describe an outcome you were going to spec by hand this week. See what comes back, then decide whether it belongs in your process.
No credit card. Free forever to start.