Anthropic just released manage agents,

which is their take on automating the

process of automating processes. In this

video, I'm going to show you guys how

manage agents works. I'm going to build

you guys a quick little demo flow so you

can see how it actually works in

production. And then I'm going to

connect that to a front end so you guys

can see how to build these sorts of

flows both on the back end and the front

end. And then I'm also going to run

through literally every button in this

new little dashboard interface so you

guys know everything that you need in

order to build these sorts of agents

yourselves. So what I'm going to do next

is I'm going to build a very simple

system, one that I build for many of my

clients many many times. It's a system

where you can basically just paste in a

transcript after a sales call and then

it'll go into your project management

tool, whatever it is. In my case it'll

be ClickUp or maybe Notion. And then

it'll populate it with a bunch of tasks

that you or your team members have to

do. So I could just write all that stuff

out or I could literally just hold down

like a voice transcript tool and say,

"Hi, my goal is to build a simple system

where I provide a transcript, you take

that transcript and use it to create a

bunch of tasks in my project management

system of choice." The project

management system I'm going to use for

this example is ClickUp.

I'm going to press enter.

And now it's going to walk me through

the process of building an agent. The

first thing it's going to do is define

what this agent is going to look like.

So it's going to call it the transcript

to ClickUp tasks. So I'm going to parse

the meeting transcripts and create

structured tasks in ClickUp based on

action items and so on and so on and so

forth. So I'm going to click create this

agent. What it'll do is it'll take this

schema the spec and it'll turn it into

my agent. But my agent isn't enough. If

you think about the way that most

automations work, you know, we have the

the actual implementation details, but

then you also have to host that

implementation somewhere. And so what

this does is this is hosting

implementation details directly on

Anthropic's back end. As in Anthropic is

going to spin up a server and then give

me a reusable little box that always has

the exact same parameters and everything

like that for me with limited networking

for safety reasons that will allow me to

then test and then roll this thing out

to, you know, within my own business or

for companies or for clients or

whatever.

And because I said I wanted ClickUp

here, what it's doing is it's saying,

"Hey Nick, you're going to have to add

some form of, you know, credential or

information in order to do this." And

so, what I'm going to do is I'm going to

create a new vault to store all this.

You can see it's now going to pull up

pull in the ClickUp credential over

here, which is pretty wild. And then I'm

going to go over here and say, "I

acknowledge this credential is shared

and that I'm responsible for its storage

and use. It has OAuth built in." Then

I'm just going to click connect. What

it'll do next is actually open up some

information. So, I'm going to connect to

my little Left Click workspace. And then

I can actually just do the the whole

connection and integration without me

having to touch API keys at all. And

this is fantastic for people that do

automation and whatnot because a big

barrier to entry is just dealing with

API keys and stuff like that.

I'm then going to click test run.

Now, we're going to have the ability to

paste in a brief transcript. And as you

can see, there's a test sort of filled

out here that says, "Here's a transcript

from our team stand-up. Alice will set

up the staging environment by Friday.

Bob needs to review the API design doc

and send feedback." and so on and so

forth. What I'm going to do is I'm going

to click send and I'm just going to show

you guys what happens, how easy it is to

test end-to-end. Obviously, this sort of

transcript is not about as long as an

actual kickoff call transcript or a

project management meeting might

realistically be. Um but hopefully, it

shows you guys just how the interface

works. You have two panels here, one

called transcript, which is basically

just a a view of your entire

conversation with the agent. Then you

have debug, which shows it in sort of

like code form so you can go click in a

little bit more and see the type and the

process data and stuff like that. What

we're doing now is equivalent to just

having a conversation with like Claude

normally. It's just we're doing this

within this sort of like this uh very

standardized container for testing

purposes. Now, if I click out of that,

you can see that we have a much larger

log here where here's the transcript,

the model then starts it's thinking.

I've identified five action items from

the transcript, three input, four and

nine output, 27,044

cash rights, probably big chunk of its

system prompt. And then now it's giving

it to us. So, I've identified these

items. Could you tell me which list or

space I should create these in? Are they

all their names in ClickUp and stuff

like that? For the purposes of this

demo, um because I want to move quickly

here and show you guys the rest of how

this whole thing works, I'm just going

to say put this in example builds / CRM.

Uh don't do any assignees or anything

like that. This is just a demo.

And from here on out, um it can now

basically do the the API call to ClickUp

in order to get that sorted. If there

are any issues or it can't complete it

for whatever reason, I can now do, uh

you know, my my debugging. I have every

raw API event over here. So, I can

literally see when the model starts,

when it ends. There's full

interpretability and accountability

here, which is obviously great for us

automators. And you can see that it's

now created all five of these tasks in

parallel. So, Bob to review the API

design doc, Carol to update, and and so

on and so on and so forth. We've even

received true. And if I go back to my

ClickUp here, you can actually see all

the tasks that were just generated. the

staging environment, review the API

design doc, send feedback to the team,

and so on and so on and so forth. And

because I gave it that constraint,

obviously it didn't do this um using

assignees. It just did it using a bunch

of um um text. After you're done

testing, it says the run went smoothly.

What do you want to do? So, I'm going to

uh based off of your conversation with

the agent in sort of the transcript and

testing, it'll actually say, "Hey, what

do you want to do?" Um do you want to

modify it a little bit by adding a

default ClickUp list or space to the

system? So, that's what I'm going to do.

I'm also going to add some assignee

mapping guidance, and then I'm going to

enter. That's now going to actually go

back and change the configuration

itself. So, it's going to ask me some

questions. I'll just say example build,

and then I'll say CRM. As you can see

here, we just changed the actual system

prompt itself.

And now that it's done, all I need to do

is say create this agent. And then it'll

ask you to test it and so on and so

forth, which you can do all the way

until you're done. After that, you'll

click on the integrate button,

or you could just tell it literally,

"Hey, I want to integrate." And now

it'll basically run you through a

step-by-step guide on how to connect

this to whatever other platform you

want.

Now, in my case, I mean, I'm not going

to connect this to a another platform

because I just want this to be a quick

little app that I could copy and paste

something into where I'll sort of know

or understand. But hopefully you guys

see how simple it would be to maybe like

spin up a quick little front-end app

where it's like, "Hey, you know, an

action item generator." You could also

connect this directly over to, I don't

know, maybe some sort of like proposal

or transcript platform. As you click in

on specific sessions, that's what I'm

doing over here. In the top right-hand

corner, you can see there's now an ask

Claude button. And so what I'm going to

do just as a demo is I'll say, "Hey,

this

agent works perfectly. What I want to do

next is I want to spin up a front-end

and then I want to connect that

front-end little chat window directly to

this agent. So when I chat with the

window, I'm basically chatting a

pass-through to the specific transcript

agent. That way I can share it amongst

my team and anybody can quickly paste in

a transcript to very quickly set up, you

know, ClickUp tasks and stuff. How do I

do this? Uh can you do this for me? So

on and so forth."

The value here is, you know, you

basically have a non-sandbox version of

Claude, which is just your own. This is

a lot more limited than, you know,

running Claude code on your end because

you're both limited in terms of your

inability to use like fast mode and

stuff like that. And then obviously I'm

pretty sure this is locked into Sonnet

4.6 at least at the time of this

recording. But something that can be

pretty valuable. And uh yeah, just to

make a long story short, if you can't

see cuz of my big fat head, this is just

like spinning out a bunch of the bunch

of the code and whatnot. So what I'll

say, which you can't see, is just give

me

a prompt I can feed into Claude code to

set this up in 30 seconds. Assume I have

Netlify and everything else ready. And

now it's going to generate me that

prompt ahead. While I'm waiting, I'm

just going to move over to antigravity

and then basically get all the stuff

ready. And I'm just going to paste it in

over here and I'll let you know build a

front-end for me just for the uh

purposes of a fun little demo.

And now I have this uh this whole

prompt, right? Which is pretty cool. So

I can just copy this. There's a little

copy modal. Paste this in. And then I'm

just going to open this up and show you

guys what that looks like. Oh, and then

also for speed purposes, I'm just going

to go fast mode, which uh here I can do

just by going to one of my many

instances, clicking fast, then pressing

enter. Then go back here, stop this, and

say, "Fast."

And now what it'll do is just generate a

very quick website for me. Okay, and

after about 30 seconds, we've now uh

done a bunch of coding and basically

spun up a front end. It's going to check

the Anthropic API key and everything

like that. And I just said, "I want to

run this so I can test this." So, now

it's going to spin me up a server. Cool,

here's my little chat. And what I'm

going to do is I'm going to ask it to

quickly whip me up a test that I can use

to verify that this works. So, I'll say,

"Give me a brief test transcript to

verify this works." Now, it's actually

testing this alongside me, which is

quite nice. And as you can see, it's now

generating me a test transcript. Okay,

team, three things from yesterday's

client review. Uh what I'm going to do

is I'm just going to move over here,

copy this, and then I'll paste this in.

Press send. And as you can see, this is

now extracting the action items. And you

know, obviously I can improve this UX

however much I want if uh we wanted them

to chat with this as opposed to maybe

Claude. But uh what it's doing is it's

now actually going through and creating

those action items. So, if I go back to

ClickUp, which is right over here, and

then I add a date column so you could

see when we created the task, and then

we sort, you can see that we've now

write a one-pager on new pricing tiers

for the sales call. That's what we just

did a moment ago. And now all I have to

do is literally just push it to

production. Voila, we we just created an

app. And we didn't just create the app

like hardcore mode, actually going out

grabbing the ENV, uh the API keys, the

credentials, setting up our own

environment, all that stuff. We're doing

it all entirely on Anthropic's

infrastructure. I guess aside from our

front end, but um this is an

unprecedented level of ease with which

we just went through that whole process.

This is something that if you showed to,

you know, somebody that was designing

drag-and-drop interfaces just a couple

years ago, they'd probably raise an

eyebrow and think that you'd smoked a

little bit too much of Brian Johnson's

DMT. So, with that out of the way, let's

talk a little bit more about this

dashboard. The manage agent section,

okay, appears over here on

platform.claude.com/workspaces/default.

And then right now we're in the agent

quick start route, but uh we can just

click

on any one of these, and you can see

that route change. Um this is basically

offered as part of their Claude or uh

Anthropic API service. And so, this is

the same like playground that you would

jump in if you were doing some sort of

API integration or whatnot. Anybody

that's done that is probably a little

bit more familiar. There's also a build

section up here and then down over here

there's some other sections like

analytics, there's cloud code, there's

manage and stuff, but for now I'll just

run you through everything here.

Obviously, we've already seen the quick

start section. Let's move over to the

agents where you could see a list of all

of the different agents that you have

running. Um you can also archive these

at any point in time by clicking these

three dots and pressing that archive

agent feature and then you can go

directly into, you know, the proposal

generator flow in this case or

transcript to click up task agent. Uh

and then poke around both the agent view

and then the sessions view.

Now, the agent view is the high-level

configuration including the MCPs, tools,

platforms, and then any additional

skills that you've added. Whereas the

session view shows you the independent

conversations, basically runs, that

you've had with that agent. And if you

click in on that session, you could see

that we actually have that that

conversation on that test run that I

showed you guys earlier where we've

created those five tasks, you're kind of

talking back and forth with the agent

and so on and so forth. You can click on

debug in order to get much more

information about what the actual API

calls and stuff look like. Then you can

even filter based off of specific uh

requests. So maybe I only want to filter

the actual agent messages that have been

sent to me. Maybe I only want to look

at, I don't know, the thinking section

so I can like look over and see how long

the thinking session has actually took

or something.

They provide this really cool visual

view of what parts of the conversation

uh are dedicated to which type of task.

So in this case, the agent.thinking only

occurred in two small little segments,

but if I close this out, you could see

there are a bunch of other um sort of

checkpoints. This one was running, then

I sent a message, then the model

started, then it did some thinking, then

it stopped, then it was idle, you know,

sessions began running, message, and so

on and so forth. They typically appear

in in clusters like this. I want to zoom

in a little bit over here because

there's a lot more sort of hidden

underneath the view. They they put a

tremendous amount of work in to make

sure that this interface is something

you could actually use for work. Notice

how here we have the agent view again,

which is what that little sort of route

looks like. But if you click here, now

you actually have your cloud

environment. So this is the environment

that we just spun up. The scope of my

environment is the organization. The

created time was 10 minutes ago. And

here you can actually see the

permissions that you've given that

environment. This environment, okay, can

connect to mcp.clickup.com.

It has no packages. It has MCP access

enabled and its type is highly limited

because obviously this can only really

chat internally between it uh and then

mcp.clickup.com. This is the sort of

security stuff that allows you to work

mid-market and then enterprise and build

systems like this for real people or

using internally in your own business.

They've done a really good job of

disambiguating between like serious

business use cases and then kind of that

old school like open claw, just give it

all your API keys and and have fun. Over

here you actually have the vault and the

vault is their way to basically share

credentials across organizations and

stuff like that. So you can see that

it's stored it and given us this nice

little modal. We can go to vault, which

I will do in a moment. And then you also

have some additional information like

wall clock time since created, the total

number of tokens in and out, which is

obviously good for cost and tracking

transparency, then the amount of time

it's been since this thing is

essentially been set. Okay, so

realistically as you build more and more

agents and then use them across all of

your apps, whether they're little chat

apps or direct integration, your

sessions will accumulate. But what's

cool is you have total overview and

oversight capability just by heading

over here to this tab.

On that environments front, as we saw

earlier, I set up a bunch of other

proposal generators here as demos.

As demos, um I should note that when you

archive an agent, okay, you're not

actually archiving the environment. So

you kind of have to do both. So I'm

going to head over here, archive this

proposal generator agent just to demo,

go back here to this environment, and

then I can either archive or delete.

Okay, in my case I'm going to delete a

bunch of these cuz I don't want these

consuming any resources, so I'll do that

here. The simplest and easiest way to

set all of this stuff up so far I found

is not to use this environment tab to

create dedicated environments, but I

basically use either the quick start or

the agents tab to create an agent and

then alongside the creation of the agent

you will create the environment and the

credential vault if necessary.

Otherwise, you'll just have a bunch of

additional environments per one agent.

Uh and you know, eventually this sort of

thing is going to be priced in pretty

hard. So, make sure to get good use

price reduction strategies earlier. And

then obviously you have those vaults.

So, I'm just going to archive those so

that we don't have to look at them

anymore. Okay, next up you can check

your analytics and I mean this is billed

just like API access is. So, I mean in

my case

it looks like I've sent 22

2.3 million tokens in and 20,412 tokens

out. I did all of that today because I

was just testing this feature. You can

see the rate limited requests here, Opus

4.6 caching and input tokens and so on

and so forth. This combines usage across

all of your workspaces and your managed

agents. So, as you begin populating more

usage and you know, running this in both

your own company and then potentially

other people's, you'll see all of that

stuff calculated over here. Obviously,

that ties into cost of which I've spent

$2.40 today to do some testing. You can

see most of that was Sonnet 4.6, but

there was a little bit of Opus 4.6 as

well.

And this is sort of month-to-date wise.

In my case, I spent a fair amount on

tokens last month, about $204 in total.

Most of that was situated kind of in the

middle of the month when I was doing a

bunch of Opus stuff for a client of

mine. You also have access logs. You can

go really deep into every single request

you made and so this includes as

mentioned those managed agents. So, I

think the logical thing to ask is where

the heck is this going? And where this

is going is very quickly, my prediction

is that Anthropic is going to build in a

visual sort of accompaniment to this

sort of communication tool that we have

here. Because the big issue right now is

we're sort of limited by our own ability

to understand systems that are laid out

as text bullet points and stuff like

that. Uh the main advantage that no-code

drag-and-drop platforms like n8n,

make.com, and Zapier have over something

like Claude managed agents right now is

you can literally just like open it up

and then you can see the way the system

works visually. You can see like this

node connects to that node just to that

node. And human brains just work really

good like that, you know, we can uh see

in one picture what would have taken us

a thousand words worth of reading in

order to really like understand. That's

where that idea of like a picture is

worth a thousand words comes from. And

you know, I I think that the second that

Anthropic cracks that, and they're

probably already working on this, we

will essentially have like a full

replacement for that sort of automation

infra. And then either service providers

like ourselves or companies that have

the know-how and the technical ability

to build stuff like that, I will

basically be able to use this managed

infrastructure to do all of their

knowledge process automation. Because

like Claude is great and Claude code is

like a coding harness is also awesome,

but you need to go one step further to

like the infrastructure layer if you

really want to start automating things

at scale, standardizing inputs and

standardizing outputs. Hope you guys

appreciated this video. Had a lot of fun

putting it together. If you guys have

any questions about this, just drop it

down below. If you guys have ideas for

future videos, then please let me know

in the comments. I actually get most of

my ideas from you guys at this point, so

anything you guys want to see, let me

know of. Last big ask is please

subscribe to the channel. Something like

70% of people that watch my content

regularly aren't for whatever reason,

and my goal is to hit a million

subscribers before the end of the year.

You'd be doing me a big solid by doing

so. All right, I'll catch y'all in next

video.