AI Dev Team: The Full Feature List
A set of background agents that assist a developer on a real codebase. They handle the work developers often skip: documentation, tests, TODO completion, cleanup, and library research. Bigger changes never happen without your review. Every edit lands as a git commit with an "ai:" prefix so you can spot them in git log and revert any of them cleanly with one command.
Below is the complete list of what the system does, including the universal features (learning, background automation, admin chat) that work the same across other system types.
A multi-step cycle (plan, build, review, fix) that picks one task per cycle and completes it carefully. Behavior changes never ship without your review, and the pipeline respects your "do not touch" list for any file or directory you mark off-limits.
Documentation Sweeps
Docstrings, inline comments, and README sections written directly in your codebase. The coding agent reads the existing docstring format first (JSDoc, Google, Sphinx, whatever is already there) and matches it exactly. Obvious code is left alone; the focus is on the non-obvious parts where documentation actually helps.
Test Coverage
Tests written in your existing framework, matching your fixtures, naming conventions, and assertion style. The coding agent reads a handful of existing tests before writing new ones so the additions blend in with what you already wrote.
TODO And FIXME Completion
Self-contained TODOs (validation logic, error handling, small helpers) get completed directly, and the TODO comment is removed. Anything that implies a design decision becomes a proposal instead, so you choose the approach rather than finding out after the fact.
Cleanup
Dead code removal, unused import pruning, mechanical pattern fixes where one file drifted from the rest. Working code is never refactored for the sake of refactoring. If a change is larger than a mechanical fix, it becomes a proposal for your review.
An explore, review, synthesize cycle that finds libraries, tools, and best practices matched to your project's real dependencies and architecture. Every recommendation answers "should I add, upgrade, or change this, and why."
Ecosystem Scan
Web searches for libraries, tools, and current best practices relevant to your stack. The research agent reads your dependencies and architecture notes first so it looks for things that actually fit, not generic trending tools.
Verified Recommendations
Every finding is checked against actual repo activity, docs quality, and maturity labels (production-ready, stable, experimental) before it becomes a recommendation. Unmaintained projects are flagged clearly so nothing sneaks in that would rot out in six months.
Comparison To Current
Each recommendation explains what you use now for the same purpose, and why the alternative is worth considering. If there is no clear reason to switch, the recommendation says so. Quality over quantity, five recommendations per cycle at most.
Actionable Upgrades
Drop-in upgrades (minor version bumps with no breaking changes) get promoted to the suggestion queue automatically, so you can approve or reject them the same way you handle any other change. Bigger migrations stay as recommendations in the research notes until you decide to act.
Codebase changes never happen without your review. Two separate queues feed into the chat agent: proposals for behavior changes the coding agent wants to make, and suggestions for cross-cutting improvements from the learning and research agents. You approve, reject, or mark implemented with one command.
Proposal Queue
The coding agent drops every behavior change into a dedicated proposals folder with a Status: PENDING header, a clear description of what to change, which files, what the current code does, and any trade-offs. The chat agent updates the header in place when you mark it approved or rejected.
Suggestion Queue
The learning and research agents write cross-cutting improvements (docs strategy, test strategy, tech debt, workflow, patterns, code organization) with priority, category, effort, and risk fields. "Show pending suggestions" lists them; one command marks any of them approved, rejected, or implemented.
Stale Nudge
Pending items older than 7 days get flagged so nothing quietly rots. Pending, rejected, and implemented items expire at 30 days. Approved items stay until you mark them done, since approved work may sit for months before you get to it.
Grounded Evidence
Every suggestion references specific files, patterns, or real outcomes. No speculative improvements, no "consider rewriting X" without a concrete reason. If the evidence is thin, the suggestion never reaches you.
Every AI change lands as a commit with the literal "ai:" prefix in the subject. You can spot them in git log, and the chat agent can revert any of them cleanly with one command. Your own commits are never touched, and AI commits use a configurable author identity so blame stays clean.
"ai:" Prefix Commits
Each coding cycle auto-commits its in-project edits as one commit with an "ai: short task summary" message. Your history stays readable, cycles are easy to scan, and reverting one cycle rolls back the whole cycle's work in a single step.
Dirty-Tree Precheck
Before spawning background work, the chat agent runs git status. If you have uncommitted changes, it waits (or offers to commit just your own recent foreground edits first) instead of tangling its new work with your WIP.
One-Command Revert
"Undo the last change" runs git revert on the most recent "ai:" commit. The chat agent reports the reverted SHA and subject so you know what was undone. Conflicts (rare in practice) are reported in plain language so you can resolve them by hand.
Configurable Identity
AI commits use a configurable author name and email set in your config file. Your git history stays clean and blameable, and the AI identity is clearly distinct from any human contributor in your log.
Slack And Discord @mentions
A 5-second-tick chatbot answers @mentions in your team channels using the same knowledge base and project context the background agents use. Casual questions, quick lookups, and spot clarifications all work without leaving chat.
Project-Aware Answers
Questions about the codebase pull from the memory bank and the project memory files, so answers reflect what the system has actually learned about your project. The chatbot knows your architecture notes, your dependencies, and your research findings.
Escalation To Flags
Anything the chatbot is not confident about becomes a flag for your review through the chat agent, same pattern the support system uses. One answer in the main chat clears the question for everyone who asked.
Foreground, Background, Or Goal
The chat agent picks the right execution path for every request. Small single-file work is foreground, done live in the conversation. Multi-file tasks go to the background agents panel with the full plan, build, review, fix pipeline. Ongoing sweeps become goals the coding agent picks up cycle by cycle.
Natural-Language Commands
"Show pending suggestions," "approve SUG_ID with a note," "undo the last change," "commit what we just did," "pause the system" all work as plain requests. The chat agent runs the right tool and returns the answer in plain language.
Scoped File Browser
A fixed set of roots (project code, proposals, suggestions, activity archive, flags, goals, reports, config) is accessible through the chat agent or directly through the admin UI. Read-only roots stay read-only, writable roots stage edits before they land.
Activity Summaries
"What have you been doing" pulls from the structured log archive and returns a plain-language summary: what the coding agent completed, what the research agent recommended, what the learning agent queued for your review. No raw log reading required.
Every action the background agents take is logged as a structured outcome. The learning agent compares outcomes against your goals and memory-bank patterns and generates improvement ideas grounded in what actually worked. A skeptical step reviews each idea against your human-source rewards before anything ships.
Creative Step
Reviews recent outcomes, flags, and memory coverage for patterns worth acting on. Groups related items so one suggestion covers many similar cases, instead of surfacing five variations of the same idea.
Skeptical Step
Verifies proposed changes against your seeded guardrails and safety heuristics. An idea that requires new paid services without a goal, or that would rewrite working code for style reasons, is rejected before it reaches you.
Execute Step
Auto-implements safe internal changes (memory bank entries, project tracking updates, internal template improvements). Everything that touches your codebase becomes a suggestion for your approval instead. The learning agent never edits your code directly.
Pattern Memory
Verified patterns get stored as searchable memory-bank entries, so every agent reads the same institutional memory on its next cycle. Over time the system gets sharper about what works for your project without you needing to repeat yourself.
Daily Maintenance
Prunes expired suggestions, writes the status report (suggestion counts, proposal counts, confidence, discovery, last logs), and runs any custom cleanup scripts you keep in the reflexes folder. The status report is what the chat agent reads when you ask "what is happening."
Log Curation Every 5 Minutes
The coordinator agent reviews what every background agent wrote, keeps what matters, deletes noise, and surfaces any errors to the flags queue for your attention. Your log history stays readable instead of piling up with transient status pings.
Git Dirty-Tree Observation
If your project repo has growing uncommitted changes with no recent "ai:" commit, the coordinator notices you are actively editing and records the observation so the system stays out of your way. Not a flag, just a note the system uses to decide when to push ahead vs wait.
Pause-Aware Throughout
One pause command stops every background agent and scheduled job at the next tick. Resume restarts everything. The chat agent keeps working when paused so you can review and adjust without anything else moving.
Four rules the background agents cannot override. Everything else about how the system behaves is driven by your config, so you can tune the rest to match how you work.
Do-Not-Touch List
Files or directories you list as off-limits are never touched by any agent, for any reason. Generated code, vendored dependencies, sensitive config, legacy modules you plan to rewrite yourself, anything on the list stays untouched.
Seeded Guardrails
Onboarding seeds two human-source rewards: never recommend paid services or new API keys without an explicit goal, and prefer small additive changes over sweeping rewrites. These rules cannot be overridden by the AI, only by you.
Codebase Changes Through Review
The learning agent never edits your code directly. Every codebase change becomes a proposal or a suggestion for your review, with evidence and specific file paths. Approved items are what the coding agent acts on, nothing else.
Full Pause Control
One command stops coding, research, learning, chatbot, and every scheduled job. The chat agent keeps working so you can review and adjust. Useful for refactoring sprints, release freezes, or any time you want hands-on control.
What Is Actually Running
The system runs as a set of background agents on your server, each on its own timer. All of them respect the system-wide pause flag and skip cycles silently when paused.
Master agent handles the chat interface (5-second tick). This is the one you talk to.
Coding agent runs every 15 minutes through a multi-step pipeline: plan, build, review, fix. Handles documentation, tests, TODO completion, cleanup, and writes proposals for anything that changes behavior.
Research agent runs every 15 minutes through a three-step pipeline: explore the ecosystem, skeptical review of findings, synthesize into recommendations and actionable upgrades.
Learning agent runs every 15 minutes through a three-step cycle: creative ideas grounded in outcome logs, skeptical review against your guardrails, execute (auto-implement internal changes, queue codebase changes as suggestions for your approval).
Chatbot ticks every 5 seconds for Slack and Discord @mentions, answering from the same project knowledge the other agents use.
Coordinator ticks every 5 minutes: curates background agent logs, surfaces stale pending items, extracts patterns from outcomes for the learning agent, records git dirty-tree observations.
Scheduler handles daily maintenance and any custom daily cleanup scripts you add.
Memory bank runs continuously as an embedding service so every search, every proposal, and every learning pass has instant semantic lookup across experience entries, memories, ideas, skills, and rewards.
All data stays on your deployment. Your code, your repo, your memory bank, your learning outcomes. Nothing is shared with any external service the system itself does not call (the web searches the research agent runs on your behalf).