!AgentDeck monitoring background audit agents in real time
*Published: May 10, 2026*
Yesterday afternoon, the house was doing what houses do.
The kids were around, things needed tidying, normal family gravity was pulling everything back into the room. I was not locked away in some perfect deep work cave with silence, a standing desk, and a clean calendar.
Life was happening in the foreground.
In the background, EMMI-AI was running a deep audit on TaskSage.
Not a quick once-over. Not a vibe check. A full dual-agent, slice-by-slice, evidence-bound audit across the app I have been building for myself. Frontend, backend, auth, AI boundaries, project routes, task lifecycle, board views, settings, billing, notifications, the whole system split into controlled surfaces and inspected from multiple angles.
I was moving around the house while a serious technical operation kept going without needing my hands on the keyboard every minute.
That contrast is still sitting with me.
Because four years ago, this was the dream. Not "AI writes code for me", not "agents replace engineers", not the cheap version of the story. The dream was more specific and more useful.
Could I build a small software engineering company around myself?
Could the machinery of planning, review, audit, synthesis, memory, and execution become strong enough that one person could operate at a much larger level without becoming fake, careless, or detached from the work?
Yesterday was one of the clearest answers I have had so far.
TaskSage is my kanban and AI assistant app.
It started as a tool for myself, because I needed something that matched how I actually think. I wanted a system that could hold tasks, projects, focus, planning, and AI assistance without flattening the messy human reality underneath it.
It has grown into one of the most polished things I have built.
That polish did not appear in a weekend. It came from years of solo building, from the usual loop of ambition, frustration, architecture, rewrites, small wins, ugly bugs, and the occasional moment where something finally feels like it has crossed from prototype into product.
But polish creates its own risk.
When an app becomes broad enough, you can no longer trust your own familiarity with it. You stop seeing the edges. You remember why a thing exists, so you excuse how it behaves. You know the happy path, so you miss the broken one.
That is why I wanted a proper audit.
Not just "does it run", but "where is the system lying to me?" Not just "is the UI nice", but "where does the product contract break under real use?" Not just "is auth present", but "where can linked resources leak across trust boundaries?"
That is a different level of question.
And it needs a different framework.
The pattern that emerged is now my complete audit methodology.
It starts by slicing the app into surfaces small enough to inspect properly. For TaskSage, that meant three frontend slices and four backend slices.
Frontend was task lifecycle, views and boards, then settings, billing, and onboarding. Backend was auth and sessions, task domain and labels, Sage AI integration, then notifications, email, and webhooks.
Each slice gets two independent auditors, Kimi and Codex.
They do not share conclusions first. They inspect the same surface separately. They write findings with IDs, severities, verification mode, and file-line evidence. Then a synthesis pass reads both outputs and arbitrates the overlap, disagreements, gaps, and false positives.
After the frontend slices, there is an FE-MASTER synthesis.
After the backend slices, there is a BE-MASTER synthesis.
Product-policy questions go into a DECISIONS-NEEDED queue instead of being smuggled into defect lists. The final artifact is a cross-track ACTION-PLAN, ordered by priority and grouped into work that can actually be executed.
That last part matters.
An audit that produces a pile of observations is not enough. I need the system to turn raw attention into a repairable plan. Otherwise it becomes another impressive folder that does not move the product.
!Audit framework folder layout, slice scoping, and phase plan
The result from yesterday was about 118 consolidated SYN findings.
That number is less important than the shape of it. The value was not "118 things are wrong". The value was that the system could preserve evidence, separate defects from decisions, catch duplicate findings, compare severity disagreements, and turn seven slices into a single order of operations.
That is the kind of audit structure I used to associate with large teams.
Now it is something I can run on a Saturday.
The dual-agent part is not decoration.
Kimi and Codex tend to see different things.
Kimi is strong at breadth. It notices UX friction, accessibility, density, odd interaction states, mobile polish, and the places where the product feels heavier than it should. It is good at walking the surface area like a user with sharp eyes.
Codex is strong at depth. It tends to dig into linked-resource authorization, route parity, framework semantics, AI prompt boundaries, and places where a backend assumption quietly becomes a security or correctness issue.
Same slice, two angles.
Then synthesis decides what survives.
This is the important part. I do not want two agents because I want twice as much prose. I want two agents because independent disagreement creates a better surface for judgment.
If both agents find the same P1, that is a strong signal. If one finds it and the other misses it, that is not automatically a rejection. It becomes an arbitration question. Was one agent seeing a real blind spot, or did it overreach from incomplete evidence?
That difference matters.
Single-agent audits can sound confident while still being narrow. They can also be right, but there is no second angle forcing the claim to survive contact with another model's attention.
The synthesis layer is where the value compounds.
It compares Kimi-only findings, Codex-only findings, both-agent findings, confirmed non-issues, severity shifts, and product decisions. It asks whether the issue is an instance, a pattern, or a policy question.
That is how you get from "the AI found stuff" to "the system produced accountable engineering work".
!Plan-mode audit phases and verification gates for the TaskSage audit
The audit has an Iron Law.
No source writes during audit.
No writes to `src/`. No writes to `apps/api/`. No package installs. No "I found the fix so I patched it while I was there". Audit and repair are separate modes.
This sounds strict because it needs to be strict.
When an auditor can change the code, the evidence gets muddy. Did it find the problem, or did it create a new one? Did it observe the real app, or did it drift the surface under inspection? Did it preserve the system state, or did it silently move the target?
For this framework, the generated diff is the enforcement layer.
Every audit workspace captures protected-path status before and after. If `src/` or `apps/api/` changes, that is not a minor process note. It is a breach. The run gets flagged and the methodology treats it as a problem in the audit, not a normal part of discovery.
Every finding also needs a verification mode.
Some findings come from direct source inspection. Some need browser reproduction. Some need integration proof. Some are blocked and must say exactly what blocked them. Pinned symptoms cannot be closed by vibes. If something claims a recent fix worked, it needs a reset, UI step, network check, database check, visible result, and verdict.
This is where I think a lot of AI-assisted engineering goes wrong.
People treat auditor prose as evidence.
It is not.
Prose is a report. Evidence is the file-line citation, the reproduction step, the generated ledger, the protected-path diff, the command log, the spot-check that proves the citation exists and means what the agent said it means.
That is the line I care about.
AI can produce a beautiful wrong paragraph. A methodology has to make that less useful than a small verified fact.
Right after the audit, I built AgentDeck.
AgentDeck is a Textual TUI and browser dashboard for watching background agents in real time. It came from the same pressure that produced the audit framework.
Once you start running multiple agents in the background, you need more than terminal tabs and hope.
You need to know what is running, what is stuck, what is waiting, what has completed, which agents are burning tokens, which ones are holding the critical path, and whether the whole operation is still healthy.
The screenshot below is from a different audit, but it captures the feeling perfectly. Background agents are not an abstraction. They are visible. They have state. They can be supervised.
!Red-highlight AgentDeck view showing background agents running in parallel
That is the missing layer for me.
The audit framework gives the work structure. AgentDeck gives the operation a nervous system.
Today, I used it for the Minecraft server migration too.
That might sound like a small thing beside TaskSage, but it is exactly the point. The same orchestration pattern can hold a deep product audit and a practical infrastructure chore. It is not a demo. It is becoming how I operate.
EMMI-AI orchestrates. AgentDeck shows the state. The framework gives the agents rails. I stay in the loop as the person who decides meaning, priority, and direction.
That is the human-machine shape I have been trying to build.
Four years ago, I dreamed of building a software engineering company.
Not just having a job in software. Not just making apps. I wanted the whole thing, the product thinking, the architecture, the security, the research, the documentation, the deployment, the systems around the systems.
At the time, that was bigger than me.
Now I look at what is around me and the sentence feels strange, but true.
Today I AM the software engineering company.
Not because I do everything manually. That would be the old bottleneck with better branding.
I am the company because I have been building the operating system around myself.
EMMI-AI is the infrastructure. PromptSage is the prompt-engineering and AI security framework. CyberSage is the AI pentesting platform. TaskSage is the product surface I use to manage and think. AgentDeck is the command deck for background agents. NeuroBridgeEDU is nearly ready as a privacy-first transcription and adaptive summary platform for institutions. FlowForge and TimeSage sit in the same constellation around time, work, and attention.
None of these projects are isolated.
They are organs in the same body.
PromptSage teaches agents how to behave within secure boundaries. EMMI-AI gives them memory and orchestration. TaskSage gives me a living product to build against. AgentDeck gives me visibility into the agent layer. CyberSage brings the security mindset. NeuroBridgeEDU brings the human and institutional side of AI into focus.
The audit framework sits in the middle of that.
It is not a one-off productivity hack. It is a way of making AI work accountable enough that I can trust it with serious engineering attention.
The meta point is simple.
A small builder can now run a Fortune 100 grade audit methodology from a laptop, on a Saturday, while the kids are playing in the house.
It costs less than a coffee to run the kind of parallel inspection that used to require meetings, staffing, coordination overhead, and a level of process most solo builders never get to touch.
That does not make the work automatic.
It makes the work scalable.
The distinction matters. AI does not remove judgment. It multiplies the surface area that judgment can cover. It does not make taste irrelevant. It makes taste more important, because now the machine can produce more than you can responsibly accept without a framework.
That is why I care about methodology so much.
Without structure, agents are impressive noise.
With structure, they become a way to externalise attention. They can inspect, compare, cite, synthesize, and queue decisions. They can keep moving while I am away from the desk. They can give me a map of the work instead of just another stream of text.
And then I can come back as the builder, not as the exhausted bottleneck.
That is the world I wanted to build into existence.
I keep coming back to the same image.
The kids are playing. The house is alive. Somewhere in the background, agents are auditing TaskSage across seven slices, producing findings, checking evidence, and building a repair plan.
I am still responsible.
I am still the person deciding what matters.
But the machinery is finally strong enough to carry real weight.
That is what technology should do.
It should amplify the human. It should not erase the human, flatten the human, or pretend the human was the inefficient part all along.
The human is the point.
This audit framework is one shape of that belief.
It is engineering discipline, wrapped around AI capability, pointed back at a real life.
The agents worked in the background. The family stayed in the foreground. And for the first time, that felt like the architecture, not a compromise.
