Mission Control: The Executive Layer for AI Agent Teams

Give Mission Control an objective and let your AI agents organize the work. Track progress, review evidence, and intervene only when a decision requires human judgment.

Comment 1

Mission Control

🌐 Live Application: https://app.missioncontrol.wallyweb.com

📖 Documentation: https://missioncontrol.wallyweb.com

💻 GitHub: https://github.com/shawnwollenberg/ai-mission-control

Inspiration

Prior to October 2025 I was leading a team of 13 engineers and really enjoyed coordinating tasks and helping the team achieve our goals. I wasn't as hands-on with the code as I used to be, but really enjoyed helping others and pushing the team forward. October was when we started working closely with Claude Code and in March, due to a loss of funding, we had to lay most of those engineers off. Instead of managing those 13 engineers it has been up to me to manage multiple terminals with Claude Code, Codex, Grok Build and Hermes through Discord. I've been extremely productive, but there has to be a better way to manage all of this. Not only do I have Claude and Codex writing a bunch of code, running tests, and managing AWS infrastructure, but I also have my Hermes agent managing my finances, handling DeFi positions, tracking my fitness and managing my day-to-day tasks.

I love that I no longer have to spend hours tracking down the exact line of code causing a problem. I can focus more on the idea, the architecture, and what I'm trying to accomplish while the agents handle most of the repetitive work.

The downside is that I now spend a lot of time jumping between terminals and tools trying to figure out what each agent is doing. Did one finish? Is another stuck? Is something waiting for my approval? Did an agent misunderstand the goal and start heading in the wrong direction?

It works, but it feels a lot like trying to manage a team without having meetings, status updates, a project plan, or any shared view of what is happening.

I also have another problem: now that it is so easy to build things, I have a hard time sitting still when I get an idea.

Over the past six months I've built several systems outside of work using a combination of Codex, Claude, Cursor, OpenClaw and Hermes:

  • Crypto smart accounts for AI agents with guardrails: Give an agent its own wallet while enforcing rules around how much it can spend, which contracts it can interact with, and where funds can go.
  • Agentic commerce platform: Allow AI merchants to sell services with licenses and receipts, while giving buyers purchasing policies and access to a dispute and refund process when something goes wrong.
  • AI token governance: Control which models people, teams, and agents can use, how much they can spend each day, and when they should automatically move to a less expensive model. For example, an agent might use GPT-5.6 until it reaches 80% of its daily budget and then automatically switch to GPT-5.4.
  • OfficeAnywhere: An AI receptionist and operations platform for local service businesses.

Between my day job and the businesses I am trying to build on the side, I have started thinking more seriously about how to organize a team of agents that can take on more of the work without me constantly flipping from terminal to terminal to Discord to Cursor.

This hackathon gave me a reason to step back and ask a bigger question:

What is the right way to organize an AI team?

What would happen if I could give Hermes an objective and let it assemble and coordinate the right agents while I stayed focused on the decisions that actually require me?

Mission Control is where I decided to test that idea.

What it does

Mission Control is a command center for managing teams of AI agents.

Instead of opening one assistant at a time and manually feeding work from one agent to another, I can give Mission Control an objective and see how the work is being organized.

Mission Control creates a mission plan, breaks the objective into tasks, tracks which agents are responsible for each part, monitors progress, surfaces risks, and pauses when something needs human approval.

The goal is not to manage prompts. The goal is to manage outcomes.

For the demo, I use a real project from one of my businesses: adding Stripe Billing to ServicePilot, which has since been renamed OfficeAnywhere.

The mission starts with research and planning. As work progresses, Mission Control recognizes that research has become the bottleneck. It recommends reorganizing the mission so implementation and validation can move forward in parallel, explains why that change makes sense, and waits for approval before changing the plan.

The important part is not just seeing agents perform tasks. It is being able to understand what the team is doing, why the plan changed, what is blocked, and where I need to step in.

That is the visibility I used to have when I was leading an engineering team, and it is what I was missing when working with multiple AI agents.

Mission Control has since grown beyond the original hackathon demo into a live application with public documentation, personal workspaces, guided onboarding, and support for locally running agents. A developer can create an account, connect an agent, launch a mission, and supervise its progress through a single control plane while Mission Control coordinates the work, records the evidence, and pauses whenever human judgment is required.

How I built it

Mission Control is built with:

  • Next.js 16
  • React 19
  • TypeScript
  • Canonical event sourcing
  • Durable append-only event storage
  • Projection-based UI architecture
  • Hermes orchestration
  • Codex-powered implementation workflows

The most important architectural decision was making the event log the source of truth.

Every meaningful action is recorded as an event. That includes creating the mission, building the plan, assigning work, detecting risks, proposing changes, approving decisions, validating results, and completing the mission.

The screens in Mission Control are then built from those events.

Mission Health, the Mission Plan, the activity log, recommendations, approvals, and the final debrief are not separate versions of the truth. They are different views of the same mission history.

I chose this architecture because I did not want the system to end up with one version of the mission in the UI, another in an agent process, and another in a database record.

With an append-only event history, I can replay a mission, rebuild the current state, audit why a decision was made, and eventually connect additional agent runtimes without changing the basic model.

There is also a clear separation of responsibilities.

Mission Control provides oversight and maintains the shared mission state. Hermes handles orchestration. Codex performs focused implementation work. Other agents can eventually plug into the same system for research, monitoring, finance, writing, and other tasks.

As the project grew, I realized Mission Control shouldn't become another agent. Its job is to coordinate specialized agents, record what happened, enforce policies, and give humans one place to supervise the organization instead of constantly jumping between terminals.

Challenges

The hardest part was not writing the code. It was deciding what Mission Control was actually supposed to be.

Some of the early versions felt like an AI activity dashboard. They showed that things were happening, but they did not help me make better decisions.

Other versions started to feel like project management software with AI added to it. That was not quite right either.

The idea became much clearer when I stopped thinking about managing tasks and started thinking about managing an organization.

That gave each part of the system a clearer job:

  • Mission Control provides oversight.
  • Hermes coordinates execution.
  • Specialized agents perform the work.
  • I remain responsible for the important decisions and the final outcome.

Another major challenge was making sure the demo stayed honest.

It is easy to build an impressive interface that makes it look like agents are doing more than they really are. I did not want to do that.

When something is simulated, Mission Control labels it as simulated. When an artifact is real, the system can show the evidence behind it. When a capability is not connected yet, the application does not pretend that it is.

That decision made the project harder, but it also made it better. A system that supervises autonomous agents has to be trustworthy. It cannot claim that work happened when it did not, and it cannot hide uncertainty behind a polished interface.

What I learned

This project changed the way I think about working with AI.

A lot of AI products are focused on making one model smarter, faster, or more capable.

That is obviously important, but it is not the only problem we need to solve.

As agents become more capable, the bigger challenge may be figuring out how to coordinate several of them at once, understand what they are doing, and keep humans in control of the decisions that matter.

While building Mission Control, I learned that event sourcing is a natural fit for this kind of system because it creates a reliable organizational history. I also learned that deterministic state matters a lot when multiple agents and processes are involved. Without it, it becomes very difficult to know what actually happened and which system should be trusted.

The biggest lesson for me is that the future probably isn't one AI assistant doing everything.

It's teams of specialized agents working together.

Those teams will still need goals, plans, guardrails, approvals, accountability, and someone responsible for the outcome.

Mission Control started as a way to solve a problem I was having every day: trying to manage multiple AI agents across different terminals. It has grown into my attempt to build the executive layer that I believe AI organizations are going to need.

Final Note

No matter what happens with this hackathon, I'm planning on continuing this process to make sure that this is the easiest way for me to manage agents. A roadmap will be defined and this will be badass :)

Built With

Share this project:

Updates