§ 01 · The Hook
The bait, then the rug-pull.
You hand Anthropic $200 a month and Claude disappears into a black box. Mansel Scheffel built a persistent local daemon that drags every token, every tool call, and every failed session back into the light.
What the video promised.
stated at 00:05 "I'll show you what a Claude command center looks like, why you don't need most mission controls you see on YouTube, and I'll drop you a prompt to build your own." delivered at 14:59
Where the time goes.
00:00 – 01:42
01 · Contrarian take: mission controls are overkill
Most YouTube mission controls add a seven-layer microservice that introduces context bloat without business value.
01:43 – 04:34
02 · Dashboard tour: observability layer
Live sessions panel, posture scores (security + context audits), token usage by model, cache hit rate — all fed from OTEL and JSONL logs.
04:35 – 09:22
03 · Task queue, scheduling, and Telegram approvals
Schedule creation with cron, ad hoc one-shot vs interactive task queue, model selection per skill, requires-approval gate linked to Telegram.
09:23 – 10:16
04 · Activity and MCP latency panel
OTEL-sourced latency and error rate for every tool type. WebFetch at 4s avg and 10% error rate signals a skill hitting access-denied walls.
10:17 – 12:05
05 · Token consumption deep-dive
Per-skill activation counts and total tokens over 24h. AI News Monitor at 32M tokens triggered an immediate audit and simplification.
12:06 – 14:58
06 · Skills & MCP panel
MCP cost and latency per server, skill cost-per-run rankings, context health score, full skills registry across all environments.
14:59 – 15:54
07 · Build your own — free prompt
Free prompt in description: paste into plan mode, Claude reads the latest OTEL and JSONL docs, then builds the same dashboard for your environment.
Visual structure at a glance.
Named ideas worth stealing.
01:43
model
Observability-First Command Center
- Live sessions
- Posture (security + context audits)
- Token usage by model
- Cache hit rate
- Task queue (edge-case only)
- Activity / MCP latency
- Skills & MCP cost panel
A persistent local daemon that reads OTEL + JSONL logs and surfaces operational data rather than launching agents.
Steal for Anyone running Claude Code at scale who wants to stop flying blind on token spend and MCP reliability
04:57
concept
Schedule-First, Mission Control-Last
Plan your AI work first; anything predictable goes on a schedule. Mission control is only for genuine edge cases.
Steal for Framework for deciding when to build a UI vs just writing a cron skill
06:55
concept
Model Selection Per Skill
Assign the cheapest model that can complete each skill. Sonnet is the default; Opus is the exception.
Steal for Cost reduction framework for AI operating systems
Lines you could clip.
00:30
"You do not need named agents to go out there and do work for you, especially if you are using Anthropic's ecosystem."
08:50
"There is no crazy agentic layer with Pikachu pictures drawn and Tamagotchi figures and stuff like that. You don't need that as a business."
14:53
"What does it actually do from a business perspective? Exactly. Just my maid vacuuming the lounge."
01:21
"The goal of whatever you're doing in life and business is to execute on your tasks with AI, not introduce all of these other systems that just complicate it."
How they spent the runtime.
Hook length10s
Info densityhigh
Filler8%
Things they pointed at.
00:53toolCowork (Anthropic)
02:15toolOpenTelemetry for Claude Code
07:34toolTelegram approval gate integration
06:59toolGamma AI deck generator
12:10toolNotion MCP
13:10toolObsidian local alternative to Notion
How they asked for the click.
14:59
link
"I've written you a prompt based off of what I built — all you have to do is copy this prompt, paste it in there, flip it over to plan mode."
Soft and practical — no hard sell. Shows the prompt live in Claude Code and points to Google Drive link in description. Effective because it delivers the promised artifact.
Word for word.
HOOK opening / re-engagementCTA the pitch analogy
00:00HOOKSo you're pananthropic $200 a month for Claude, you have no idea what it's actually doing under the hood. In this video, I'll show you what a Claude command center looks like, why you don't need most mission controls you see on YouTube, and I'll drop you a prompt to build your own in the description below. Let's get into it.
00:13HOOKSubmission control is a really interesting concept to me mostly because I think it is completely unnecessary for what people out there on YouTube are currently building it for. While they're technically super impressive from the business use case perspective,
00:25HOOKall they're doing is adding to the context bloat problem. They're introducing a seven layer microservice that absolutely doesn't need to exist.
00:32HOOKYou do not need named agents to go out there and do work for you, especially if you are using Anthropic's ecosystem. It's way more efficient just to use skills and have them running on demand on schedules and things like that.
00:43HOOKMore importantly, if you wanna have this front layer where you can communicate back and forth with an agent, that's why they built Cowork. It is literally the sole purpose of this thing, and it can do 98%, if not more, of what you can do with your AI operating system in an IDE inside this little graphical user interface that's much better for business people out there.
01:01HOOKYou can check out the video on the screen right now if you wanna know how to build your own AI operating system inside Cowork itself. For this video, I wanna focus on the contrarian approach that for me, my command center is observability first because that's where I think most of the value in actually having this thing comes into play.
01:17HOOKAnd then, of course, inside here, we have got some kind of task functionality because there are a few edge cases where we would actually want to launch agents from inside this panel and we'll get there in just a second. But please, everybody, take a step back.
01:29HOOKThe goal of whatever you're doing in life and business is to execute on your tasks with AI, not introduce all of these other systems that just complicate it. Skills exist for a reason, and we're gonna exploit them as much as we can inside our environment. Great.
01:42And now that all the boring practicality stuff is out of way, we can get into this video. So our command center is to handle in flight sessions, our task queue, and our schedules all in one place over here, and we can go through it layer by layer. More importantly,
01:55this thing is a persistent daemon, so it is always running locally on my system. It will go out there and find things that it needs to do, make sure my schedules are running as they should be, and finally, it will report on literally anything that we can get our hands on. When we're looking at what Anthropic gives us, it gives us JSONL logs, which is just tracking everything that Claude and Claude co worker use, And then also, we have OpenTelemetry
02:16now, which they finally released to people on the Max and Pro plans. Previously, it was only for enterprise people and that's how you see this shiny little mediocre dashboard inside Claude code in the GUI. This dashboard over here is fed partially from otel, but that's what we can exploit massively over here because there is a ton of documentation.
02:33So we can build a lot of real time info. As you can see, our dispatcher is running and everything is working as it should be. We have no live sessions running currently.
02:40We'll kick one off in just a second. But posture is a really important thing to have on our observability dashboard because it tells us two of the biggest problems that you will have in your business.
02:49One of them being security. Now, I have another video on this and exactly what this skill does, but essentially it's a skill that lives in our environment and it runs out there doing an audit finding things like opportunities for MCP poisoning, various other MCP attacks, skill problems, various settings that we have in our environment that we might want to change because it can be exploited.
03:06So we could run that task from this dashboard and you should be running it regularly, probably on a schedule. But then if it found anything, you would be able to see the entire report over here so that you could act on it. Now me having worked in cyber security for twelve years, you can see that I always keep my environment completely not up to date and in the worst possible practice.
03:24But that's because it's my dev environment and I don't really care. On the right hand side over here, we have context. And this is solving the context bloat problem that everybody has been facing.
03:32Again, I have another video on this as well. Anything that I mention here will be in the description below. But what this skill is doing is it's running through everything in your environment where you're being drastically inefficient with the way that you're handling context.
03:42With the goal being to turn all of that around by looking at this report to figure out what you can do to be better at using context within your environment. So these two things are never static. You're not going to run the skill once and yes, we're set for the rest of our lives now.
03:55Because AI evolves, the entire landscape evolves constantly. These two things will need to be run on regular intervals to make sure that you are doing the best practice at the time of whatever it is that is happening. So for me, these are the two most important things that we are currently trying to solve now.
04:09Then next up, we have a quick panel on token usage, and that's just to give us an overview of the number of tokens that we've used by model over the last x number of days. This ties in with another panel that we're gonna look in just a little bit.
04:21As we scroll down, we see the cache hit rate. This is super important. You wanna make sure that you're hitting Anthropix
04:25cache servers as much as possible because, obviously, that will save you some of your usage limit. These panels over here, they are important, but I'm not gonna go into them because they're not important to this video. What I do wanna focus on next is this mission control
04:38and this is what a lot of people are doing now because they're trying to piggyback off of what paper clip and Hermes and whatever those things are that go out there and work autonomously for you. So you can build that functionality for sure, but you have to think about why you're building that functionality. For me, if I'm looking at doing something like researching leads or things that I know are predictable,
04:58I don't need mission control to that. I don't need a task board. I can just set up a scheduled task.
05:02There is no need to have this little agent window running away and doing things. If you're in co work, it's easier than ever. You can just set up a scheduled task right over here.
05:11If you're in here, you could just set up a cron schedule which you could do straight from your IDE or in this case, we obviously built in the capability to do that down here. So before I'm about to come into my mission control and do anything, I'm going to be planning my business life out and figure out what needs to run on a schedule and what I might want to do on an ad hoc basis and make sure I have concrete reasons behind both of those things.
05:32Then once I've figured that out, I'm going to go into my environment wherever that may be and I'm going to start with the stuff that I can schedule so that everything is in place running on autopilot already. Now, if I wasn't using Cowork and for whatever reason I wanted to use this mission control, I would be able to click over here and it's pretty much exactly what Cowork has.
05:50We've put in a name so we could say morning brief and spell it like a weirdo. And then down here, we can just set the time. I want this to run at 09:00 every single day of the week.
05:57Then it sets up our cron schedule. We can give a task title and any details. This is obviously where we need to give it the name of the skill.
06:04In this case, it would be the morning brief skill because this is gonna be the command that gets sent to Claude. If that wasn't clear enough, you can obviously come down to your list of skills that we have mapped from our environment and you could select it to go and run the thing based on there and it could be enabled by default.
06:17Then we would just hit run and we would have it as a list inside our scheduled tasks over here running away on its cron schedule and doing whatever it needs to do. Then once I've done that, it brings us onto the case of okay, cool. Now I have some ad hoc tasks that I need to run.
06:30So we might then come up to our queue task and again, very similar window. We have separate options over here. So we can either have an interactive session where we can have a back and forth with the agent inside this little panel over here or we do a one shot which is basically just firing a skill that we know works making it happen once.
06:47Make me a Gamma Deck on Claude computer use. The MD file is in my deliverables folder. Something that also is important to note here is that by default it's going to be selecting it from the skill.
06:57If you are creating skills, one of the most efficient things that you can do is obviously assign the model. This again helps you with all of that context bloat. You don't want everything running with Opus just because Opus is the best.
07:07Many tasks don't actually need this. For a complex task like creating a Gamma Deck, it might sound like you need Opus but you don't.
07:14Unless this thing is gonna be writing and doing a bunch of other things, you can easily get away with Sonnet because most of the AI work is done by the gamma agent itself, obviously. So we can get away with Sonnet for this and that's exactly what we're going to do.
07:26If I had many tasks running at the same time, I could set a priority to make sure which one goes next after the other based on that little setting over there. And also you can have requires approval. This is important if you're doing things ad hoc where you need a human in the loop before we do that and I've built a panel just for that.
07:42So what I'm gonna do is I'm gonna hit requires approval and I'm gonna queue this task. Now, what this thing does is it's also linked to my cell phone via telegram.
07:51So while this thing is waiting for approval, say something kicked off while I had to suddenly nip out for something, I could then come on over to my telegram agent over here and guess you can't see it on camera, but there you go. It's asking for approval. All I need to do is hit approve.
08:05That then changes on screen as you can see and the agent is now gonna start running through this thing and do the task that I asked it to do. That's when we scroll back up here just to make sure everything's working as it should And very, very soon, this thing's going to populate a live session based on the agent task that it's got ahead of it.
08:21So it's moved into running and you can see over here that we've got two live sessions. One is the router from the Haiku agent that routes tasks between everything. And then this one is just an interactive session of what's actually happening from the Sonnet agent over there.
08:33So it's going out and searching in real time. This is just a live tale with GREP, so it's nothing really crazy over here. But it's finding the relevant files, reading them, and then it's gonna write the PSP or in this case, it's going to use what I've already got there, which is the framework that I wrote for that video.
08:47So I'm gonna send it off to Gamma and do what it needs to do. And you can see over here that this thing went and found my PSP framework that I wrote for the video. So it's going to use this and it's gonna send it off to our Gamma agent.
08:57And you can see that's why it's much better to use something like this. There is no crazy agentic layer with Pikachu pictures drawn and Tamagotchi figures and stuff like that. You don't need that as a business.
09:07You just need to make money or execute on your goals. That's the whole point of this. Everything else is just a mess that you are one day going to have to manage or troubleshoot or deal with.
09:15HOOKYou don't need that crap. Just use co work. And with that micro rant out of the way, we're going to get into some of the more valuable things in here, which is understanding
09:23HOOKwhat's actually happening in-depth in our environment because this is how we refine, save money, and make the work that we do way more efficient. So this dashboard is all about activity that's been going on in your environment. My favorite part of this is understanding the latency and error rate of all the tools that Claude is actually running into in my environment,
09:41HOOKspecifically with MCP and APIs as well. That's going to help you understand where things could be going wrong as a part of your skills. For instance, in web fetch, if we constantly have a massive error rate, that could mean that one of our skills is constantly trying to access something that it can't.
09:55HOOKOne of the most popular things is where it gets an access denied problem, in which case we could go and address that. But obviously, we would want to make sure with more information first. And that's where we get into skills over here and understanding how often they run and how much they cost and things like that.
10:09HOOKSo activations is really important because it shows us how many times over the last twenty four hours our skills have been activated. So we get to see what we use most often, which obviously forms part of this picture. But then as we dive down further, we can see the frequency associated with the consumption.
10:25So our AI news monitor over here, ran it over 23 sessions. You can see it used 32,000,000 tokens.
10:30So this was something I addressed earlier because as soon as I saw that, I was like, why the hell is my news monitor using so many tokens? So understanding things like this help you become more efficient as a business and mostly is how much you're spending with AI. Because if this stuff was actually going out through the API and not on my subscription,
10:47it would be such a waste of money. This process ended up being so massively simplified with the exact same result.
10:53I'm gonna see a massive change in this. Next up, I obviously have to do ExcaliDraw. That's generally hungry because it draws lots and lots of slides.
11:00But the idea here is that you would be able to go through this and audit your environment to understand how to make it more efficient. We can then obviously see if there were any failures. Thankfully for me, I had absolutely none.
11:09And we can also come and have a look at any previous sessions that were run. So this is the one that we just ran in the other window over here. You can see that this one has now completed.
11:18So it left that queue and it's come across into here where the recent sessions that have run over the last don't know how many days, but we've got 19 here displaying just 10 of them. So this was the task that ran. We got our session ID, the model that was used, and how long this thing ran for.
11:32Pretty straightforward. It wasn't doing most of the work. Again, it was set off by Gamma.
11:36But the idea here is that you would be able to come down here and filter down to see if any of yours have failed. Something you could then do based off of this is obviously have event driven decisions. So if something failed, you could get alerted either on your phone if it was that important or you could get alerted by something else anywhere that goes into another system so that system can then respond to it, maybe even redo the workflow.
11:56Whatever it is that you needed to respond to could happen as a result of this. That's again why observability is so important. Making event driven decisions proactively and in some cases reactively,
12:06but at least without the human having to sit there and worry about it in an anxious state. This is very important if you're setting up an AI operating system for your clients. You wanna know that their things are working.
12:15So if something does go down or something fails, they're not going to know about it unless you have set up something like this for you to monitor them or they have someone on-site obviously. Then last but not least, we go over skills and MCP in detail. So for me, I don't mind using MCP that much, but it is really hungry at certain times depending on the task that you're doing.
12:33If you're doing this as part of a larger system where there are constant back and forths, it can really pollute whatever it is that your AI is working on. So this kind of helps with that. It helps us understand
12:43how much our tool runs are costing us with MCP. It tells us how slow everything is and the slowest parts of these tools. So for me working in Notion, update pages really slow, create database is slow, search is slow.
12:56There are ways around using MCP directly. We can use code execution, which is another layer that I will discuss in another video because it deserves its own deep dive. Point is there's lots of ways around these problems that we find, but unless we know about them, we can't solve them.
13:10So if you're using Notion heavily and you don't really need the visual layer, you just only know it as a place to store documents, you might want to switch to Obsidian because then everything's local and all of the other benefits that you get with that. For me, I prefer a visual layer when I'm working, is why I use Notion And this helps me understand how performant my system is.
13:27For me, this kind of latency is minimal and even the token usage here is completely minimal. So I don't care. There's no way you can convince me to change that based on this.
13:35But it is all valuable information. Obviously, we want to understand our skill cost per run as well, so we've got that included in here. This morning brief is more than the AI News Monitor because this is something that I'm currently working on in three environments running through multiple systems, so these metrics are a bit skewed.
13:49But the idea here is that this will obviously tell you what your most expensive skill is per run, not the accumulated one like we had in the other view. The idea being that you can assess all of this and then figure out how you can make these skills more performant because you wouldn't want them wasting as much tokens as they do.
14:04And then last but not least, we have the context health over here, which just tells you, again, based on the video that I had on context engineering and such things, how you could be better inside your environment using context overall in various places. And on the right, we just have a skills registry that shows us every single skill in all of our environments
14:21with a breakdown of what they do. This is just for a user perspective, so you have an audit of whatever's going on in your environment. Good to keep track of these, you can get rid of them whenever you don't need them, obviously.
14:30So from this perspective of the video, I think this is where the value of a mission control comes in. Realistically, co work again is just there for people who don't want to use an IDE. So using any of that other stuff is just fluff, guys.
14:41It is a distraction. It's pretty. It looks great and sure the people who put the time and effort into that, it is amazing, really smart, doing crazy things.
14:49But what does it actually do from a business perspective? Exactly. Just my maid vacuuming the lounge.
14:56CTAThat's the only sound we hear resonating when that answer comes up. But I do want to give you guys the capability to go and build this thing for yourself.
15:02CTASo I've written you a prompt based off of what I built and this thing will go out there for your environment, read all the latest docs that it needs to and then pull down the same information. You can obviously tailor this to the way that you want it, specifically taking out things or including things. Again, if you don't need that mission control functionality, just completely get rid of it.
15:18CTAAll you have to do is copy this prompt, paste it in there, flip it over to plan mode, of course. You don't just wanna yolo your way through this. I have told this thing to do some of the latest research for the hotel logs and JSONL just so that it understands what it needs to do.
15:30CTAThen you would hit enter and this thing will go out there and do that and probably ask you a few questions along the way. And that's really it in a nutshell. You can add or subtract as much functionality as you want.
15:39CTADon't think most of you are gonna need that Mission Control there. But if you do, you can obviously just ask this thing to go and add that. Other than that, that pretty much wraps it up for this video.
15:46CTASo thanks very much for watching, guys. Leave some comments below, I'll get back to you as soon as possible. Otherwise, check out the videos on the screen now.
— full transcript
§ 05 · For Joe
Build the dashboard that tells you what Claude is actually doing.
Steal this architecture
Skip the agentic theater — the only mission control worth building is the one that shows you where your tokens go.
- Hook into OTEL (now on Max/Pro) + JSONL logs as your data layer — this is the same source that feeds Claude Code's built-in dashboard.
- Lead with a posture panel: security audit + context efficiency score. These two never go stale and they catch expensive problems early.
- Add token spend and cache hit rate as top-of-fold KPIs — these are the two numbers that change your behavior fastest.
- Treat the task queue as a sidebar, not the hero. Schedule everything predictable; only queue truly ad hoc tasks.
- Wire a Telegram approval gate for any task that touches something sensitive — human-in-the-loop from your phone, no desk required.
- Assign the cheapest model that works for each skill. Sonnet is the default; Opus is the exception.
- Steal the free prompt from his Google Drive and run it in plan mode — Claude reads the latest otel docs and builds the whole thing for your environment.
