Hi there. This is Graham from Open

Hands. And like everybody else, I'm kind

of navigating this world of AI-driven

development. And I try to use

AI agents to do many of the jobs that I

do every day to, you know, accelerate

and be able to build more things that I

wouldn't have been able to do otherwise.

And you know, we're all trying to figure

out out how to best utilize AI in our

workflows, but I've learned a few things

over the process of doing it myself. So

I thought I'd start this video series to

share them.

So the first one that I'd like to share,

and you know, of course get feedback on

it. I'd love to hear what people think,

is how I've been trying to orchestrate

my daily workflow so that I mostly do my

daily workflow through prompting AI

agents,

as opposed to me managing my own daily

workflow and then asking an AI agent to

do parts of it. So it's basically an

agent-driven workflow where I pop out

and do other things occasionally.

So

in order to manage this workflow, you

need a number of tools. I'd say the very

bare minimum is you need to be able to

manage your to-do list, your

communication, and your

code or the products that you're

generating.

And to manage my to-do list, typically I

use Linear. Jira's another popular tool

for that.

But for the purpose of this demo, I'm

I'm just going to use GitHub issues as

the source of my tools essentially.

Um

and

for communication, I typically use

Slack. People use other things like

Teams or things like that, but I'll I'll

use Slack for this demo.

And then for the source of my source

code, I'm going to use GitHub, and of

course GitLab and Bitbucket are popular

alternatives for that.

So, the basic idea behind this workflow

is you first start up your agent, uh

whichever one you like, but I'll use the

OpenHands Agent Canvas uh to

run agents in a a way that allows you to

uh kind of visualize them

and uh and manage them. So,

here we go. Uh grab the agent canvas URL

and and put it in here.

And so, now now I have my uh

you know, agent control center. And

as I mentioned, you need to use several

tools in order to get this sort of

workflow to work. And so, I'll jump over

and add uh MCPs to customize

and provide external access to uh

various external tools.

So, uh first is GitHub. Uh just pop over

to GitHub, go to the settings page,

scroll down to developer settings,

and uh personal access tokens, get a

fine-grained token,

generate a token,

do like OpenHands Bot Token,

choose the resource you want to handle,

which is like OpenHands,

uh the OpenHands organization,

and then I can do uh OpenHands OpenHands

is one repo, which is our main repo, and

then software agent SDK, which is our uh

SDK repo.

And give the appropriate permissions.

So, I'd need things like content, pull

requests,

uh issues,

and workflows. And so, that's pretty

good set of things to give my uh

personal access token.

So, I generate the token.

And uh don't worry, I'll delete this

after uh the demo here.

And then um we'll also add Slack. And

so, in order to add Slack, you need a

team ID, uh which you can grab by just

going to your uh

team.

Um going to Slack uh on

your

uh

web browser.

And then you can also uh set up a Slack

bot. So, I I set up this Slack bot, new

big bot, for my own personal bot.

And you can uh connect it to your

favorite workspace,

add the channels, and then grab the bot

token.

So, I'll put that in here as well.

So, now I I have the two connections.

And this is where the fun begins. Uh up

until now was pretty vanilla if you've

used agents before.

But, the interesting thing about my

workflow is um I actually have a skill

that

basically walks through all of the tasks

that I was doing in my daily work. And

so, um before I had the skill, what I

would do is every day I would go out to

our task management software like

Linear,

um browse issues on GitHub, uh look at

my Slack communications, and try to

organize all of that stuff.

Um but, the great thing about this is

that this will now organize all the

stuff for me.

And since I have a skill installed in my

workspace, I can just tell the agent

do my daily workflow.

And so, typically this will work.

And um but, in this case I'm doing

something a little bit different than my

daily workflow cuz I'm not going to uh

use Linear because I have some private

stuff on there.

So, instead, what I will say is

make sure to use your MCP tools for

GitHub and Slack looking only at private

information.

At the end, give me a structured report

of all of the things to do today, and

then give me my first task to do.

And so, uh the nice thing about skills

and stuff like this is that you can

actually, um you know, start out with a

base and then diverge in any uh way that

you need to. So, this will uh take a

little while. Uh because it takes a

little while,

and I typically don't like waiting,

I will um

it set up an automation to run it at the

beginning of the day.

Uh

typically 6:00 a.m. every workday. So,

that when I start working in that day, I

have a list of all of the things that I

could uh possibly be doing. And um the

OpenLens Agent Canvas has a few things

that make that really uh easy and nice

to do. Like, we have an automation's

thing where you can kind of set up a

cron job like thing

uh to do that sort of uh automation, but

I'll maybe talk about that in a future

video.

So, anyway, I'll let this run for a

little while. Um it should take uh a

bit, so I might fast forward through

this part. But when it's ready, we can

circle back and uh try to take a look at

the result. So, the workflow finished.

It took a a couple minutes, but not too

bad. And uh this is what it looks like

here. So, you can see it says, "I've

gathered everything from GitHub and

Slack. Here's your structured report."

And I kind of specified the structure.

Um these are

uh you know, immediate action. Um it's

uh kind of the types of things that uh

you know, we could work on immediately.

Um PRs awaiting your attention, PRs

requesting your review, um and assigned

to issues.

Uh Slack highlights,

and uh GitHub notifications requiring

action.

So, this is good, but I personally um

get a little bit overwhelmed with all of

the stuff that I have on my plate. So,

now that we're all moving at agentic

speed, it's kind of hard to manage this

huge list of things. And so, uh

I personally find it more useful to have

the agent tell me one by one which thing

I should be working on.

Um when I'm using something like Jira or

Linear, it gives me a priority order of

all of the things that I want to work

on, so I can walk through it in priority

order. And so, this is an example of uh

that. So, it gave me my first task, and

it said um you just got CI unstuck by

removing the unused uh clock three

import. Uh the build is rerunning now.

Once it's green, um unblocks uh feature

work for the week.

Um and then uh this is the only PR open

with changes requested status. It's a

substantial 623-line PR uh that a team

mate needs to wait to move forward on.

So, um give me like I can say uh give me

links to those.

And it will give me links, and I can

click through and start working on them.

And another thing that I uh like to do

in this workflow

is um

to

start another agent working in the

background to resolve any

easy-to-resolve issues while I do the

work myself. So, another thing that I

often do, and it's actually part of my

normal workflow, is

dispatch another sub agent via the agent

canvas

to

remediate all of the failing CI or

unaddressed review comments

on

my open PRs.

And so, I can get this agent to kind of

um dispatch another agent to start

working.

And so, then I go through, I take a look

at uh these PRs, and I I start working

on them. Um I'm not going to actually

bore you with the details of me working

on them, but uh I can do that. And then,

in the meantime, while I'm working on

these, uh I can have the agent go

through and dispatch uh dispatch an

agent to work on the other parts. Then,

when I finish this, uh typically what I

will do uh then is I'll go back, and

I'll say, "Okay, I finished those. Uh

give me the next issue to work on." And

then, I can just continue doing this,

you know, essentially all day. Um as I

uh I get next issue, next issue, next

issue. And on good days, I will not have

to leave this interface at all. I can

just, you know, mostly work uh through

the agent uh agent canvas here.

So, um

yeah, that that's the majority of the

work uh that I do here.

And uh

I I love to have more feedback on this.

In future videos, uh I will talk about

how I scale up parallel workflows, um

how I get more security and safety when

I'm running all of these agents in the

background, uh you know, how to do uh

credential control, um how to improve

agents uh as they work more and more on

these tasks, how to automate repetitive

tasks, and other things like that. So,

hopefully this was helpful. I'd love to

have any comments. I have people uh

comment on YouTube or join the Slack

community or other things like that.

Thanks a lot.

>> [music]