Human-in-the-loop AI
How anything gets better, step by step.
Ideas, feedback and bugs come in. People and AI agents decide, plan, build and verify under rules you set. Each item has one person or agent responsible, and the rules say which checks a result must pass. The result is released, linked to every request it answers. Every step records who acted and what proves it. FEATit is the independent mission control for people and AI agents, with any AI vendor, in one place you own.
One idea, three views
The same piece of work, seen by everyone who cares about it.
Follow one customer idea from the first request to a verified release, and to an answer for everyone who asked. On your own, you see all of it. In a team, everyone sees their part. Pick a view.
Solo founder
“I have ideas, users and a few agents, each in a different place.”
Your ideas, your users and your agents in one place.
The idea
Payment reminders
“Send customers automatic reminders when an invoice is overdue.”
7 customer requests linked
- Lena
- Customer B
- Customer C
- Customer D
- Customer E
- Customer F
- Customer G
Decision
Build it for release 2.5
On release
- LenaReplied: “Just what our finance team needed.”
- Customer BTold Mon 09:05
- Customer CReplied: “Thanks, switching them on today.”
- Customer DTold Mon 09:05
- Customer ETold Mon 09:05
- Customer FReplied: “We also need SMS reminders.” — filed as a new idea
- Customer GTold Mon 09:05
7 of 7 told on release day · 2 wrote back to say thanks · 1 asked for more, filed as a new idea
What you get
- Ideas and feedback land together, so you build what’s asked for.
- Your agents do the work. You make the calls.
- Everyone who asked hears back on release.
Product lead or PM
“What are we building, why, who is on it, and what shipped?”
Always know what you’re building, why, and who’s on it.
Decision
Build it for release 2.5
Plan
F-0031 and 5 tasks: 2 for people, 3 for agents
- T-0201Detect overdue invoicesAIbuild-agent-01
- T-0202Schedule and retry remindersAIbuild-agent-02
- T-0203Reminder APIAIbuild-agent-01
- T-0204Reminder email templatePriya
- T-0205Reminder settings screenPriya
Roadmap
- Release 2.5
- F-0031 and its 5 tasks
What you get
- Decisions are recorded with their reason.
- One plan for the work of people and agents.
- Every release lists exactly what it contains.
Engineering lead or CTO
“Can agents do real work without us losing control?”
Let agents do real work without losing control.
Rule for this step · Build
- Implement
- Agents may act alone
- Merge
- Needs a person
History
- Tue 10:00AIspec-agentdrafted the spec for F-0031Confirmed by Jonas
- Tue 11:15AIbuild-agent-01took T-0201, with a planDetect overdue invoices · commit c7d41e0, attributed to its session
- Tue 11:40AIbuild-agent-02took T-0202, with a planSchedule and retry reminders · commit 5b90a3f, attributed to its session
- Wed 09:05AIbuild-agent-01took T-0203, with a planReminder API · commit 0e8f2c6, attributed to its session
- Thu 15:40AIbuild-agent-02moved T-0202 to done — held for a personConfirmed by Priya at Thu 16:05
- Fri 10:20AIqa-agentran the test plan
- Fri 11:00Tomchecked it on staging and signed off
- Fri 11:30Jonasclosed F-0031 — not one of its implementersRelease 2.5 contains F-0031
What you get
- You decide, for each step, what an agent may do alone.
- Every change an agent makes traces back to the work session that made it.
- Someone who didn’t do the work signs it off.
Shaped to your process
Shape it to how you work.
No two organisations work alike. FEATit takes the shape of yours, with the views, pages, knowledge and rules each team needs, and your people and AI agents work to it.
Views
Design the view you need, with no code: a board, a list, a table, a matrix or a chart, with your own filters, groups and columns. Keep it for yourself or share it with the team.
Pages
Your wiki and your dashboard in one: the knowledge a team needs, next to its live views, its roadmap and the decisions waiting for it.
Documents
One central context for people and AI agents. Concepts, specs and decisions sit beside the work they shape, and people and agents read and update the same source.
Statuses
Model your processes the way your organisation works: your own kinds of work, the statuses each one moves through, and the checks it must pass before it moves on.
Rules
Set a clear definition of done for each kind of work, and how much a team takes on at once. Start from a template, then tighten it where quality matters most.
Structure
Mirror your organisation, from business units to products to teams. Access passes down automatically, and roles can be granted at any level, so an enterprise makes exactly the exceptions it needs.
Every organisation shapes its own flow.
Name your own steps and decide who owns each, a person or an agent. Set the checks work must pass to move on, and have it signed off by someone who didn’t do it. Here are three organisations, three flows.
Example flowSoftware team
- CollectResponsible: AIagent
- DecideResponsible: person
- BuildResponsible: AIagent
Before this step: At most three at once
- ReviewBack to Build if changes are neededResponsible: person
Before this step: The tests pass
- ReleasedResponsible: personAIagent
Before this step: The code change behind it
Before this step: Closed by someone who didn’t build it
Agents build and a person reviews. Nothing is released without passing tests, the code change behind it and a sign-off from someone who didn’t build it. Bugs go straight from Collect to Build.
Example flowAgency
- BriefResponsible: person
- DraftResponsible: AIagent
Before this step: At most five at once
- Internal reviewResponsible: person
- Client approvalWaits for the client’s answerResponsible: person
Before this step: Only after internal review
- DeliveredResponsible: person
Before this step: The client’s answer, noted
Before this step: Signed off by someone who didn’t draft it
Nothing reaches the client before an internal review. The client’s approval is an Action, work that is not code, closed on a note of their answer. Delivery needs a sign-off from someone who didn’t draft it.
Example flowRegulated team
- IntakeResponsible: AIagent
- AssessResponsible: person
- BuildResponsible: personAIagent
Before this step: At most two at once
- Security reviewDocumentationSide by side, then on togetherResponsible: personAIagent
- Compliance reviewResponsible: person
Before this step: Only when both are done
- ReleasedResponsible: person
Before this step: Evidence that someone checked the work
Before this step: Closed by someone who didn’t build it
Security review and documentation run at the same time, and compliance review starts when both are done. Every release carries the evidence of its check and a sign-off from someone else.
Flows can branch by the kind of work, run steps side by side, loop back when something is not right, wait for a person’s confirmation, a date or an event, and act the moment work arrives, by setting its priority, assigning it or telling the people who asked. For each step, you decide whether an agent may move work on alone, with a person’s confirmation, or not at all.
Below, one example flow in detail, step by step, from Collect to Tell.
Collect
Who may actA personAIAn agent
Example flow
- Responsible
- AItriage-agent
- Gate
Ideas, customer feedback and bugs come in as items on one board: by email, from a GitHub or GitLab issue, or from your team and its agents. Each request is linked to the idea it supports.
Example flowIn the demoJonas files “Payment reminders”. It links 7 customer requests.
Reports come in from inside any app, and requests that ask for the same thing are grouped, with each asker counted.
Decide
Who may actA personAIAn agent
Example flow
- Responsible
- Mira: build it?
- Gate
Whether to build it, the priority, and the reason are recorded with the decision, and with who made it, a person or an agent. Anything an agent files can be checked before it counts, and a check that cannot decide says so instead of guessing.
Example flowIn the demoMira decides to build it for 2.5: 7 paying customers asked. Weak receivables management is our top churn reason.
A rule for each step: an agent may act alone, needs a person’s confirmation, or may not act.
A check that can say “I don’t know”
Every check on an agent’s work gives one of three answers. A check that cannot tell holds the work for a person, instead of letting it through unseen or blaming someone for a failure that was not theirs.
- Passed
- The check ran, and the work meets it.
- Failed
- The check ran, and the work does not. The reason comes with it.
- Cannot tell
- The check could not run. Nobody is blamed, and the work waits instead of being rejected.
A person can look at work that is waiting and vouch for it.
Design and Plan
Who may actA personAIAn agent
Example flow
- Responsible
- AIspec-agent
- Gate
A person or an agent drafts the plan. The work splits into features and tasks for people and agents side by side, and lands on the roadmap.
Example flowIn the demospec-agent drafts the spec: F-0031 and 5 tasks, 2 for people and 3 for agents.
Decide
Who may actA personAIAn agent
Example flow
- Responsible
- Jonas: questions decided? plan approved?
- Gate
A second decision: is the plan right? Whoever your rules name, a person or an agent, approves it, and the approval is recorded with the plan.
Example flowIn the demoJonas approves the plan.
Build
Who may actA personAIAn agent
Example flow
- Responsible
- AIAgents and Priya
- Gate
People, your own agents, or both do the work. An agent’s session, its plan and its code stay with the item. With the FEATit app on your machine, you see whether each agent is working, stuck or waiting for you. Watch any of your agents’ terminals live, from wherever you are, and type the answer it waits for.
Example flowIn the demo3 agent tasks land commits attributed to their sessions. One move to done waits as a hold until Priya confirms it.
Verify
Who may actA personAIAn agent
Example flow
- Responsible
- AIqa-agent and Tom
- Gate
Every result is verifiable. Closing a piece of work says what was done, the code that delivered it is linked to it, and its history shows who did what. Where you want more, require the code to be in before work counts as done. Add a sign-off by someone who didn’t do it, a person or an agent.
Example flowIn the demoqa-agent runs the test plan and Tom checks it on staging.
Automatic checks on the results: whether it builds, whether the tests pass, and the release test.
Decide
Who may actA personAIAn agent
Example flow
- Responsible
- Jonas signs off: merge and release?
- Gate
The decision to merge and release, with a sign-off. It can require someone other than the one who did the work.
Example flowIn the demoJonas, who built none of it, signs off the merge and the release of F-0031.
Release
Who may actA personAIAn agent
Example flow
- Responsible
- AIbuild-agent-01
- Gate
Every release knows exactly which work and which code went into it.
Example flowIn the demoRelease 2.5 ships and passes its release test. It knows it contains F-0031 and its 5 tasks.
Tell
Who may actA personAIAn agent
Example flow
- Responsible
- AItriage-agent
- Gate
The work is not done until the people who asked for it have heard about it.
Example flowIn the demoThe 7 customers who asked hear what was done and how to turn it on. A reply asking for more becomes a new idea.
Everyone who asked hears what was done once it is released. A reporter who asked to confirm can confirm, and anyone can reply that it is not solved.
Requests that are clear before work starts
A vague request costs the most once someone has started on it. When a request is filed, FEATit can ask the few open questions in short rounds. Then it writes a clear brief the person reads, edits and confirms. Whatever stays unanswered is listed as open, so work does not start on a guess.
It is FEATit’s own AI, so a work area switches it on when it wants it, and it runs on the model that work area chooses.
Work that waits comes back by itself
Some work cannot move until something else happens: another piece of work, a date, or somebody’s answer. In FEATit an item can wait on any of them. It shows why it waits and how the thing it waits on is doing, and it leaves the to-do lists in the meantime.
When the wait is over, it comes back by itself, so nobody has to remember it and the roadmap stays honest without a weekly cleanup.
Every step carries evidence
People and AI agents work side by side and are recorded the same way. Whoever did something is named, and an agent can never pass for a person.
Open any piece of work, even months later, and the whole story is there: who asked for it, who changed the priority and why, who picked it up, and what was delivered. Nothing in that history can be rewritten, and every change names who made it.
Every change to the code is linked to the work it belongs to and to the agent that made it, automatically and in the background. Nobody waits for it, and it works wherever your code is written.
What each agent used, in tokens, is recorded as it reports it.
Your code stays on your machines. Only a short description of each change leaves them, never the files, the changes themselves or who wrote them.
How commits are attached to the workOn every piece of work
- Who asked for it, and why
- Every decision, with its reason
- Who worked on it, a person or an agent
- The code that delivered it
- Who signed it off
Everything you expect from a work tracker
Backlog, priorities, roadmap and releases are all included.
- Ideas, feedback, bugs, features, tasks and decisions in one place
- A short reference for every piece of work, like F-0142
- Work broken into parts, and linked to what it depends on
- Your own statuses and rules for each team
- Threaded comments, attachments and watchers
- @mentions that notify the person
- Saved views, releases and a roadmap
- A history nobody can rewrite
- Live updates
- Linked to GitHub and GitLab issues, and requests by email
- Your whole work area exported whenever you want, and imported into an empty one
Your people are not monitored. You can see what your AI agents are working on right now, and FEATit does not show who is looking at what.
What FEATit does not do
- Tie you to one AI vendor
- Host your code
- Replace your IDE
Seen from your seatHow solo founders run their agentsHow product teams plan with agentsHow engineering leads keep controlHow heads of AI govern every vendorWhat the AI delivers, and what it costs