are back here just doing another team meeting.
So we're gonna jump on and just hop on today
and talk through some shaping projects we're doing
to shape up some of the agentic workflows we have.
So this is gonna be just a chat with our team.
I'll bring everybody on if they wanna be on here.
And just to open it up,
like just open up, like the symphony came out
like a few days ago, a few hours ago,
and I watched this video
and I sent it to our team last night
and not everybody had a chance to watch it
cause it was like 11 o'clock at night.
So we'll watch it real quick right now
and just wanna see what you guys think of it
and then talk about some stuff.
So let me share this,
make sure I don't totally blow up everything.
So this was from Ryan Carson.
If you guys saw this tweet,
he shared this thing about symphonies.
I just thought this would be fun to watch.
Hey everybody, I've got the new symphony orchestration
set up with codecs and it's amazing.
So I wanna show you this.
So here is the TUI.
So you can see symphony is running.
It's got five agents running concurrently,
throughputs 40,000 tokens per second.
This particular run has been up running five minutes,
eight million tokens in so far.
This is the project that it's running.
So symphony is connected into a linear.
So let me just show you that
in case you don't know what I'm talking about.
He's running on a 50 inch Dell monitor,
if anybody wants to know.
So this is a spec basically the OpenAI released
called symphony.
And it essentially turns your repo into a code factory.
Now you have to do some work here to get it working,
but it was pretty plug and play.
So you get that running, you boot it up
and you can see that it's working right now
on five different issues in linear.
So here's codecs running a little sneak behind the scenes.
So I've got, I switched to work trees
just cause it's kind of built here.
Okay, so this is linear.
This is in the default view.
You can also view this as a board if you want.
I'll go super big just so you can see for a second.
So you've got, this is the symphony project.
So you've got backlog, you've got to do,
you've got in progress, rework, human review.
So this one is ready for me to look at.
Merging is, so what I'll do is I'll go in
and I'll review this and then I'll drag it over to merging
and then it automatically uses a skill called land
which helps merge the PR and then you can see done.
So that's kind of cranking.
And let's go back to the list view.
So one is currently emerging.
It's actually, this was a task with 20 subtasks
and we've got a few more issues.
Cool.
Okay, I think you guys get the idea.
So let me share this, sorry.
So hopefully you guys could hear that.
So pretty cool, a couple of things
that I thought were like wild with it
was just like the ability to kind of,
I mean, we've seen some of these before.
This one is just very simple.
The symphony is obviously it's coming from OpenAI
we have a number of tools.
Like this is kind of the sweet spot would be to move now
like from like, I told someone recently,
like we're going from like me working
to like me using AI as a resource.
Like, let me look this thing up and it gets me an answer
and I come back to my coding.
Then it's like, now I'm working with agents
and it's like kind of coding alongside me.
And then now then it was just like,
hey, we're just prompting it to do various things.
Sort of the next layer up is like now orchestrating
multiple parallel agents at once to do multiple tasks.
Cause like don't, you can't sit there
in the terminal or whatever interface you're using
and then like prompt the next thing
and fix this and do this.
Now it's like, go work on all this stuff
and then come back and I will just review it
and make sure it's-
So we'll like,
so I was curious, he has a few,
if you guys want to follow his link here
in the chat for the team, but just look him up.
He's got some, he's had some content today,
but one of the,
this morning was like he woke up and he had had like a bunch of stuff working last night
and then when he woke up this morning they had it had found a new bug that was not part of the
original scope and it created its own ticket in linear and then it moved it into the backlog so
he like basically he was like oh it's this is like the first version of AGI now like it's like kind of
finding stuff on its own and logging his own own bug so it's interesting i think there's like a lot
of different time with looking at the AO orchestrator i think maybe gen that potentially
have you messed with that that look one you were using when i saw it
yeah uh it's actually uh it's that's funny because right now one thing i've been thinking
a lot it's like how much of my time should be dedicated to like creating tools that orchestrates
agents or like tools adjacent to agents because like everyone is looking at it this now but
basically uh what i was building was a stretcher where i can handle and delegate work more easily
to those agents and especially like how to add the necessary context to to do it
and this in symphony in a way it's it's uh pretty much uh some of this but what i've
been thinking a lot like uh to be honest i think the real value right now is to taking those open
source things taking all those tools that are being uh launched and doing what we are trying
to do which is basically okay how do we fit this in into our workflow so we become uh that
agent native team uh that uh the the joffrey humbly talks about where you are actually a team
of people that are specialists in managing agents and make sure that agents work
because in the end uh it's coding like the agent breaks and you have to basically debug the agent
and you go and see the sessions and two calls and it's pretty much the same thing and i think
right now a bunch of different tools are spawning to make it easier for you to see
uh to see what's what is what the agents are doing i was also testing mission control doesn't
know do you guys yeah i started playing with mission control too um very cool like it loads
up all dot codecs are dot clouds from your local files and show them in a nice dashboard like all
the agents are the sessions it's very interesting yeah that's good i think like this is just
something to be experimenting with like so uh one i just want to like talk about that today like
this is just it's cool it's out like we should we should figure out how to um there's another
janata that wants to join i was i was ready to show what it does like yeah scans are all open
sessions and all history uh basically because all this is stored in your machine so it takes
all this data and shows you on a on a nice nice dashboard and you can see like memory for the
agents the skills and stuff uh this one doesn't see all my items because i'm running it on a
closed environment but i'm seeing it for test like it created this one where basically it's a
uh codex agent and it shows here but like it's a local uh it's just a md file on my computer
inside to to see it better let's say very it's but it's interesting um can you drop the link uh
to that one yeah sure we have we'll get a good list of links going um yeah one like just
experimenting i know you've spent a lot of time experiencing with a lot of these different ones
the the confusing thing is they're all starting to do the same thing which is when you get into
the ai like everybody's like oh open claw started then there was like tons of forks of open claw now
there's like you know a lot of versions of symphony and then um i saw perplexity computer out as well
so there was like a web browser version of that um and i had a friend who went deep into perplexity
computer and he was running his whole business on it and then basically maxed it out in like three
days um of his like the highest plan of whatever he like maxed it out and so it was gonna be like
a few thousand dollars a month to keep it going at that rate so he basically found something else
but they just released like a local um version
of that, which kind of runs in your toolbar to do various tasks.
It's getting towards this thing I talked, I can't remember if it was with you guys.
There's a great podcast from Darkesh and Elon Musk on all the future of agentic things.
So it's like three hours long.
I do recommend checking it out because it's very technical.
It's the co-founder of Stripe and an engineer, so they stay very technical on a lot of it.
And so generally where all this is going is like, what can a computer do or how would
I work with someone?
Like I'm kind of working with you guys, like where my entire interaction is like assigning
tasks or talking in Slack, or maybe there's kind of conversation back and forth.
How can we get it to where you can do everything that you could do through the interface of
a computer?
That's kind of where it needs to get to for these like sort of virtual employees, these
agentic employees.
And then of course the next step is in like bringing it into like a robot and actually
interacting with the real world.
So that's like the next piece, but before we get there, it has to be like basically
as efficient as if you hired an employee like in another country and you just worked like
remotely with that person, it should be able to do everything that that person's doing.
And so that's just an interesting thought.
There's a lot of cool nuggets in there as far as like the future and where that's all
going to go.
And like the fact that there's a very small chance that any of this AI will be able to
control like for building something so much smarter and more powerful.
And there's so many more AI intelligence versus like human intelligence.
Like why would we have a chance at controlling that?
It's really good.
I still feel really positive and uplifted from the, it's kind of like ends in a pretty
depressing state, but like bringing it back here is like now we're trying to figure out
like how do we take a lot of this work, which you again, kind of being like almost like
the manager role, like it was you managing like one employee, like you're a junior developer,
like do this.
Then he like does something.
You're like, do it this way.
Now do it that way.
So you're just kind of like, you know, over their shoulder, micromanaging this one poor
employee.
Now it's kind of like backing up a little bit and they're getting a little bit more
reliable to where you can have multiple running in parallel and having it kind of chop up
things.
And I think specifically for like, I think as it applies to us, like reactive work specifically
I think would be massive, although the span of a reactive task could be everything from
like a bug to like a minor feature request to like something that really should be a
project that somehow landed in reactive.
So we have to kind of like filter through these different lenses, but I think just saying
just keep experimenting with stuff and like officially for our team as well.
Like I know we said, you know, get the max plan, get whatever.
Like I'll I was thinking like we should each just have like 200 bucks a month to just spend
on whatever AI experimentation you want.
So just like have $200 and just like set it on fire and don't even think about it.
But I mean, don't do that.
But like basically just don't overthink it.
Like because for such, this is a crazy time in history where like for so little money,
like so ridiculously small amount of money, you could 5X, 10X your output.
It's just unbelievable.
So we'll figure that out admin wise.
But like I just I think like I talked to another founder and they're like, oh my gosh, like
I'm like the AI subscriptions are taking over our business, like all the SAS subscriptions
used to do.
And I was like, great.
Like like hand like give them a get everybody a credit card and just let them go crazy with
it.
Like if one person figures out one workflow that saves the company a ton of time, like
great, like go hack it and test stuff and you know, right.
So that's how I would, yes, that's kind of my thoughts so far on it, like just keep experimenting
with it.
I've wasted a lot of time, well not wasted, I'd say like researched a lot of spent a lot
of research time on OpenClaw and went down a bad rabbit hole trying to make it super
secure.
Didn't work out very well.
Now I'm back like trying some other things.
But I think I'm going to try to my next experiment was to kind of experiment with the orchestration
components a little bit.
And one thing we landed on, so one thing I do want to do as a team is like just go back
to framing and some breadboarding on a good next step for what's something we know we
could build right now.
Because there's a lot of unknowns, there's a lot of like rabbit holes of like things
we can go and experiment with and play with.
And that's where I got lost.
I was like, oh, cool, I got OpenClaw set up and all this stuff and like, what do I even
want this thing to do?
Like, like, I kind of like have built.
built a robot, and then I don't actually need a robot.
I just built it because it was cool.
So kind of starting a little bit with, OK,
let's take a real workflow.
How would we go and attack reactive work?
Or how would we attack something else in the team,
like something that's a little more concrete?
So we landed, we chatted yesterday
with Lucian Chinada a little bit about a plan to kind of what
we could do for the team, and really came down
to an Anovo CLI, or CLI, as Chinada says.
And then we would have a way that you guys could interact.
I also saw Perplexity, the founder of Perplexity,
was basically telling people MCPs are dead.
They're super slow.
I saw Peter Levels tweet the same thing this morning.
So immediately, I was like, well, forget MCPs.
Let's delete that.
Those are gone and dead to us.
MCPs were so last week.
Those were so like February 2026.
But yeah, we can't wait.
What was that?
That's 2000 and late.
Yeah, 2000 late.
But so having something where it kind of gives us
all the flexibility to experiment with stuff,
and then, but you're going to need us like,
because there's like, you need some hard data or data
that we can interact with on the, like,
so I think having a CLI or something that can talk
directly to the APIs, because the whole Anovo dashboard
is built on APIs.
So all of that stuff is accessible.
We could figure out a way to prep that.
So it's like very easy for LLM to process where everything
is in the structure.
But that's kind of one thing.
So we're going to move to that in a minute.
But first, isn't it, and you're going
to say something about the orchestration structure, maybe?
And you're muted.
Sorry, I muted you because you're a dog.
You removed my power to talk.
I just said, my dog's going to start barking down here.
It's a symphony.
I shouldn't say it's something I found this morning
in those lines of, like, everything now
needs to be a CLI.
And maybe we can use this tool to turn
the dashboard into a CLI.
It's basically a tool to scan the repository
and expose the API and expose whatever
you need to be exposed as a CLI.
It's the current CLI, all the things.
Yeah.
Yeah, no.
I'm now experimenting with Obsidian for my personal notes
because of their CLI.
It's so good.
And also, I think it's more agent-oriented
because now everything on agents is just an MD file.
And the Obsidian files are just an MD file.
So I feel it's more closer to what the language
the agent is talking.
Yeah.
I don't know how to use that.
Yeah, we're deeply integrated with Notion.
So I see an end to that at some point.
Like, we'll figure that out.
But it's not going to make sense to have it all.
And the incentive for Notion is to not allow you to, like,
they allow you to export your data.
But the incentive for them at this point
is to create the closet as much as possible.
So I don't know if that's good for us,
especially us that we know how to create our own software,
which is cool.
Like, we can create something like the dashboard,
very personalized.
So that's fun.
Yeah, for sure.
So I think always going back in true form,
like, OK, sounds awesome.
Now what?
And how did that happen?
Cool.
Are you getting that, or is that me?
Give us a thumbs up.
I've gathered you here to tell you about it.
I'm getting that.
Welcome to my TED Talk.
Anyway, I'll leave it there.
Maybe it's like, OK, we'll see if it jumps.
So just coming back to our good old trustee process here,
like, a little bit of a frame of, like,
if we were going to go do the next batch of work,
like, where would we want to land on the now?
Like, what are the actual problems here?
I started this just before the call.
But obviously, we're currently experimenting with, like,
we're all experimenting stuff, but we're
having to recreate a lot of connections in and out
of Lenovo.
And so I think one of the things, you know, eventually what I was seeing is like, there's some sort of like data hub, or some sort of, and I'm not going to a solution of like, oh, it's definitely a CLI, or it's definitely MCP.
But the idea would be that you could feed your whatever agentic workflow orchestration system, like in like dynamic data that's in a controlled way, and it's logged.
Like, that was the other thing I was going to say is that like, all access and, you know, changes are logged, you know, so we could say like this, we can kind of blame, you know, Janata's, you know, AO, like orchestrator or whatever, you know, for a task, like we can say, oh, this thing changed on this date or whatever.
I do think like, we don't currently have, like tasks are not a part, or I'll be specific, Notion tasks are not part of the Innova-Dash like right now. I'm gonna drop the link just so you guys have it in case, jump in.
But like,
the,
so we don't have, we're not part of the dashboard yet. But we do have like, sort of the task grid idea. But it doesn't really, you know, that might work. I think what's, what I'm seeing work really well with the linear approach, and don't worry, we're not gonna like switch to linear, you know, tomorrow, which I was like, oh, forget Notion, we're all in on linear now, like,
but is the is kind of the same thing is kind of how Notion works. There's like a task level, like, here's the headline of the task. And when you click into it, there's like, there's a whole lot of detail in there. And that's what we're gonna have to have to make this work, like a task grid is not gonna work for an LLM, because it just is one sentence. And really, to me, it's a scratch pad of like ideas, like, I need to do this thing, do that thing, whatever.
It's not, it's not like, it's not breaking down, like what the actual issue is, and referencing files and like giving a lot of context. Because I think part of it will be having we talked about yesterday was like, can we have tasks come in and then send it off to an agent to go properly shape it up and get deep? It's not, I would say shape it up, but just to define it more to get clarity to make it more concrete, like, users are saying button doesn't work, I hit the button, it breaks.
You know, something crashes, whatever. Can we send that off with like, and it's like, oh, it's on this screen on this thing. Yeah, when you hit this, it's missing a whatever argument, something. And then it gets more specific. And you can look and be like, yep, that makes sense. Fire that off, off it goes. And then you just, you know, when you get to the review state, can you click on it, view it, make sure it's good.
But it's the time in between, like letting that thing go sit for, you know, a while. And even, it's not so much like, oh, well, I could that one's gonna take five to 10 minutes to go fix and come back and then I'll do the next task. It's that like, you actually don't care when this happens. Like, I'm just gonna queue up like a bunch of work for my Thursday, fire it off, off it goes. And then like, you're gonna get like, at some point, it will alert me that I'm back in review process. And I'll just come back and then I'll like pick it up again.
Versus like kind of being in this like single, single thread, it's like having a single core CPU, like you're just able to do this one thing, and like advance the next thing in like a very linear approach. But this will let you go like multi thread, essentially, to have a lot of different things going.
And I have seen in the sym, like when you set symphony up, it is really, as far as I can see, like set up for a specific app or specific project, I believe, like you actually install symphony, like in the repo. And so like you kind of set that up, let's say for like tribe just by itself. And then again, it would be sort of like tribe flutter, maybe we can find it, like put them in one, you know, directory with both repos that you know, however, that works.
But we would need to like, that's one approach, just kind of setting up on like a project level. But anything else you guys are like thinking as far as this could work? And like, I'll start with the bad part out bounds area here.
Well, are there any natural, I guess, guardrails or stage gates where you don't want them to do something? I guess, without being sequentially approved, you know, like something with billing or sending invoices or something like that.
That would be on like sort of the workflow piece. I'm thinking there's like a hub of data, just that, like concrete, factual data that like there is a client and its client's name is this, there's a project, the project name is this, there's like these tasks for this project here with details.
Um, you know, if there's more information about those, we'll give it like a nice
interface to like, get me tasks, get me like, Hey, I want to work on this project.
It fetches like a couple tasks you work on, you know, go through something, shape
them up or whatever, um, and then fire them off.
Um, what I don't want to do is be, I don't, I want to kind of keep it like
workflow and agent agnostic so that like, Janata can try something and
Lucia can try something and I can try something and Greg, like we all try our
own little spin on it and see what works.
Um, cause I don't want to necessarily like, like, uh, lock in on like, Oh,
it has to be these seven steps.
And then, you know, cause I don't know if we're there yet.
I don't think we're yet there yet to like, uh, sort of hard code the workflow yet.
Um,
ever made the context.
Thank you for keeping me honest.
It's not a problem.
It's just a thing.
It's just a fact.
Uh, one question, uh, is this initial version, are we thinking about it read
only or it, or it allow the agent to also update the data back to the system?
I think it needs to update too.
So you can say that like, um, yeah, I would say read and, you know, right.
Um,
yeah, my suggestion.
Okay.
I'll change it up here.
Read it up here.
Yeah.
This one was like, uh, it's, it's
and you could, we could do this actually.
Let's just be really prescriptive here.
Um, cause you don't really, you're reading client data.
Um, you're going to like, uh, read and write tasks.
We'll just say projects.
Um,
and projects are the frame and that's great.
Or, and also like metadata, like where, when it starts, when it ends.
Right.
Yeah.
And I think like having, yeah, meted, like basically reading everything, the
framing, the task grid, also the, whatever notion tasker, because when we say
project, the project in the dashboard is the same project as notion.
So they're one in the same.
It just, there happens to be like, uh, it's stored in the database.
Um, so like, I'm going to do the same thing.
One-to-one like super base notion, basically.
Exactly.
Actually, if you go down here, um, you can, I'll just, I'll
make this just for context, but there's like, we'll call it notion projects
and they have an ID and that's just things like that.
Um, and this would be like, you know, name.
And how this, this is getting synced today.
It's a Chrome job or?
Every five minutes it syncs.
Yeah.
It's pretty, it's pretty in sync and it does a two way, um, it
merges everything two way.
That seems to be, it's on an edge function right now.
Just for context right here.
Chrome drops.
So my, and I would say the source of truth is the dashboard.
Um, like if I deleted our notion account, technically I could like dump everything
back in, like all, I set up all the projects again, not fully true.
Like we have a lot of other information in notion, but like from a standpoint,
like the projects are backed up.
Maybe that would be an outcome.
Like we make sure that source of truth of projects.
That's the current state.
Source of truth of projects is a context.
Yeah.
Maybe that could be a outcome.
You know, the source of truth of tasks is in the dashboard.
That's interesting.
And I think that's, I mean, probably like a morning or something like that.
So we can make it work.
They all say it's a new source of truth for tasks.
Cause I think like the way that notion works, it's, it's, uh, like we're
syncing the project database right now.
I just literally have to like, it'll take me 15 minutes to like also sync the
task database because all the relationship fields and how it's all linked and all
that is already in there.
Um, okay.
Question.
Does a task in notion, how does a task of, uh, who, where were the questions?
Oh, did someone delete?
Oh, sorry.
I deleted.
I'll leave it out here as a sticky cause I like, um, does a task in notion
equal a task in a, um, slice or task grid?
I think ideally they would be one-to-one.
I think like,
I would fall back to like the problem.
Cause I feel it's not crispy enough yet.
It's like pretty good.
Though like many small reactive tasks is just like a lot of load and I really like the thing of like
Like we can consider that like we've tackled this problem if we have somehow the ability to like
Queue up queue up a bunch of things and kind of like break the dependency of like one-to-one like i'm watching a task
I can just say like oh I want this done like fire off. I'll come back and review a batch, you know
so
If you're focusing on like just this like problem and solution then task grid is kind of not
We could decide like projects or it's just a reactive
project problem
Yeah, we could drill into it more
And to be honest, uh, I don't know about you guys, but for me
uh, if i'm using task grid
Uh, usually notion just becomes a backfill like I do it after like just for the tracking purpose
Like I do everything on the that's like
That should be a problem right now. Like the fact that you even have to do that is kind of silly
like that's
I usually I usually just keep on the on the notion for like tracking purpose, but
uh, because
yeah, I feel because I think like
It's it's a bit slower to to move on on on the on the notion
Structure so
I usually like just have the tasks and I just go like
How i'm doing it now is basically I take I copy the task grid
And then I break it down into markdown files for the implementation
And then I have the agents running it
Uh, and I just have like amd file
That's basically a representation of the task grid on my local repo and updates it locally
And when I finish my session, I just go to the task grid and I update it there
um
So in this workflow, you see I don't I didn't have to touch the notion tasks itself
um
so yeah, because I also that's something we may need to question about our process like
how much do we need notion tasks if we have the task grid now like
I don't know if i'm i'm questioning too much but like
I do. Do you really need the notion tasks at this point? How you guys are using it?
Yeah, I want to I want to chime in on this because to me they're like fundamentally totally different
Like task group is fantastic tool to get like a map, you know
I'm building like this thing. It's like this slice and like I make progress in the slice
and I use a lot the
Tasks in notion for taking notes, you know, I do deep research on something
yeah, so
They have like a layer deeper, right? Like you're actually
um, this is like great if you just want to sketch out like quick thoughts that you want but like I think what you're doing
is they're like
What also we may be able to do is if if we click into?
like this would just be the title of a task and we click in it and it does have like
Maybe there's a notion icon next to it and you could open it in notion. Oh, that doesn't mean perfect
Yeah, because if we like the same way we go
Up here and we click notion for the project level
we should be able to like
Click on the task level
and go to a notion task because that way I could do is I could I just I could like create create create create
And then if I need to go deeper I can tap on it and there's already a notion task that exists
So all it would do is open it up
and if I and then I can also go into the
Project level and I could look at my this one doesn't actually oh here it is
This one has like whatever projects are here
and we could actually
These would be one in the same. So like you could
If you want to look at it through this way, I can have these different statuses. That's still accurate
but you could kind of see it here. The only difference is we probably have to have like a
catch all like
notion no slice associated box
Right if we created that there's uh, I want to kind of like drive further on this because
To me like the bigger pain point to me
They're very distinct the way I work on the project and the way I work on reactive is like totally different worlds
that's
if
if we focus just on like
reactive because
Like you're working in the task grid. It's like
Yes, I can take like more notes on a specific task, but essentially it's like sequentially, you know
First task and the next task has to happen some parallelization may happen
But then reactive is like almost 100 like they're just unrelated I just like can fire them off
all off
separately, so I think if we
My worry is that if we just get kind of carried away to like connect task grid with like notion tasks and ai agents
We'll create like more work than like we could have focused on just like a more specific problem
Which is like reactive?
tasks are just like too many small things and then we would kind of cut out
a bunch of like problems to solve for which is that tighter frame maybe we
maybe if we focus on on reactive and I think that's a good a good decision for
us to just like talk reactive maybe we don't need to to to worry about like the
source of truth we can remove it or we can make it so that reactive project is
a different type of project on our dashboard and then instead of using the
task grid module we just show a cam bone module which would show that one to one
of the tasks in ocean and then this is kind of solved for the reactive
structure because that's true like reactive is just like this this line of
work it's really combined style like I have everything you have to do and
usually you can execute a lot of stuff in parallel but like we ironically the
the statuses for projects are the statuses for tasks right now I think I
think they're exactly matched so like we could I think I'm with you like we could
actually task grid is a tool like you know Ryan gave us is a good tool for the
job like if it depends on the right product if you're like in a new feature
build you're sketching out a bunch of ideas but I do agree like we may have a
ticket come through as a reactive task that's kind of like this thing that has
to move through the system so it's kind of like a small it's a mini project you
know but it's kind of in the wrapper of a project because we have to have
something to build and track time and clients and all that too so it's like a
it's like a child project of a real project that's what is beautiful about
notion is you can just kind of keep going in this like as deep as you want
so if you started making like notes and sub pages and all kinds of stuff that's
great for notion to just go crazy with all your research notes but I think what
we need now for the and I do think that the that layer of depth to it is as a
hundred percent needed for anything agent like we're gonna have to load up
all the research and then even when it comes and proposes its plan it's got to
put it somewhere so it's got to go into a thing it's I can't just right now like
so maybe like one of the I don't know if this is a problem or a context but just
like right now like you know tasks what we call task in the in the dashboard are
basically just like a single line you know text note or something it's like
there's no you know page or depth to it at all and so that that's I put in the
problem status because it's it is plan that's blocking us right now to come to
the outcome of being able to use this for agentic workflow and so what we
could do is like I put under here if you're good or there's like no changes
to the task grid just focus on notion tasks just and I'll just say notion tasks
sync so right we will end up with from a data standpoint we have tasks and I'll
just say like if there's no task ID a slice ID then it just won't be in the
right because this could have like a notion task ID here yeah and these lies
could be a property like if you want like a new notion property on tasks if
we want to make this tracking the other way go notion back to the yellow if if
we want to like if we want to have that task on notion associated with a
specific slice we could just add a slice property on notion and basically uses
the same name or because then would kind of just for that we could add that later
on I just want to because that's yeah you're really like what kind of in sync
like what I was thinking about is exactly that like our structure of like
the columns I think like a couple of some years ago or like months ago we had
like discussions about naming like proper naming the column and I think we
really have like good columns for the process like inbox is like something you
client complained or you know and like shaping is like okay we decided that we
should do something about it so let's research like what is even this thing
what are the steps to reproduce and then move to like dev ready like the problem
is clear and we can just go and like fix it and that lends itself well to like
automation thing you know we can just like move it to shaping an agent picks
it up like does the investigation moves it to dev ready and I mean that that's
not like tight enough but also like that
That's open like a lot of things because like we need to give like the agent like independent
access to like read logs, read like digital ocean metrics, like the server crash or whatever,
like click through the app.
So it's kind of like there's a lot that could be done just on like that small thing.
I would say like, I think there's a good hard line, like a wall to build here on the out
of bounds, like just like the task grid is good for us for now.
I think we're all looking at it like from an architectural standpoint, you're like,
yeah, but there's tasks in a slice and there's tasks in a Kanban board, like tasks are tasks.
So yes, let's totally merge it later.
And like I could see a version where we like start up, because you may also have this thing
where you like are in a project and I would grab just a random one here and we have a
bunch of tasks like, and you're like, oh, actually I want to go deeper into this and
maybe like I click into this and I can have the notion page that's associated with this
down the road.
I don't think it needs to be a now thing, but like that way it kind of gives, you could
use whatever tool you want and you're not feeling like, what I don't want to do is end
up with like a question of like, do I use the task grid or do I use the Kanban board?
Like, cause they go like, you're down two different paths.
And I like the idea of it.
Like I could start task grid and then move it into like a different thing if I need to.
But I think the, all we have to think of right now is like, let's just leave that off the
table because it's safe to say that like, this is super not useful to an agent right
now.
Cause it's like, this just has like random thoughts of, you know, and it's all like whoever
the developer is like, this really only means something to Janata who's building.
I don't even know what this necessarily would be like.
This just says, you know, and not all of these are just, some of them are like admin tasks.
Some of them are like, get this thing, you know, fix that button.
It's just enough information for us to remind ourselves and to not miss something when we're
having a competition with a client, we can just quickly throw them on the board.
So I think it's a great tool again, just, I think for this, we're actually wanting to
go very deep on each task because each task is going to be like a thing that the agent
works on and needs a lot of information.
And then even if we only give it a little information, it needs a place to put lots
of information and a good plan.
So I'm good.
I'm good with that for now.
And just, we'll just scope it to a different project or else you have to make a lot of
design decisions.
I'd link Lucian is what you're saying is like, do we go like, and even then Janata was like,
let's make like a way for us to like add slices in Notion.
And then so I specifically said like no accessing task grid in Notion, cause I already, I did
think about that when I was building it.
And it kind of goes down like, it's a weird thing.
It doesn't quite match like the way that, you know, if you haven't, cause you can label
a slice anything.
So just keeping them track so they don't have like certain slices aren't showing up in the
wrong projects and tasks anyway.
I think that's good.
Is there anything else problem-wise we should think of?
One interesting problem to add is about like, no, actually that's good.
It's probably for another shape in the, what I was going to say that this is good.
I'm just curious what it is anyway.
It was about like, because one of the contents that we have, like one of the pieces of data
that we have in our system is the communication with the client.
Like the reports, everything they send, their complaints about what we did and it's all
linked on different channels.
But I think that would be a different project because what you need probably is something
to first kind of grab everything and everything, like organize it on the same place.
And then we need probably some layer of a agent that would help us filter this out and
then create tasks that would be executed in a flow.
But that would be like a separate piece of the workflow, I imagine.
One, okay.
Yes.
So maybe like client communication, like with Slack and email and all of that will like
And just, I don't mean like agent answering customer, I just mean like
Just context, building the context.
Yeah.
But so one thing that we can do though, is all of the comments are synced from Notion
back to the dashboard.
So we actually do have like every single comment is in a comment database.
So worst case.
Like you could screenshot the Slack message,
you could copy paste the message.
And what's cool is it actually creates over here
like a thread, right?
Of like everything that's being said.
If I send an image, it will start?
It should show the image, yeah.
Let me find it.
Nice, that's perfect.
It even shows the video.
If you show like a Loom video,
it like puts a little player in there.
Nice, that's so cool.
But yeah, you would need to extract, you know, the text,
but if an LLM ran into an image,
it would know what to do with the image.
Yeah, every local with you,
that basically it's like a extractor of content.
And for a video, it does like every five seconds,
it screenshots and adds transcription.
So like the model knows when I send a video,
like this is a video about this feature
and does this kind of transcription.
The other thing that came up yesterday was like,
we need, we don't really have like,
I'll just say like an LLM friendly, like-
Knowledge base.
Yeah, knowledge base or context, you know,
of a like a particular project.
So it could be cool if over here,
we could have a way to like add resources
to a client level.
That's the trick.
It's not a project level.
It's something that needs to be at the client level,
you know, it's-
It could be the equivalent of an area
in the paramethodology.
It's something that if we don't have an end in mind,
like clients can stay as with, hopefully forever.
And-
Just a little parenthesis,
this kind of like in solution space,
maybe not the solution for this, or maybe it is,
but like area is like, you could have like credentials
and also like executors, you know,
like a agent that reads logs, you know.
And you can like manage access,
like let's say, Junaid, you're working on X tech
and like no one else is.
So maybe you have like the API key to Innovo
that knows that you're working on X tech
and you see et cetera, everything.
You're not like admin, so you don't see billing
and that's it.
So that would be part of like area, you know,
in my mind, like the agents,
like that read logs or whatever.
Nice, that's cool.
So probably, yeah, I mean,
like this does already have in the dashboard,
probably the CLI or, I mean,
we are literally talking solution now,
but I mean, the CLI probably will need some form of logging
or some stuff, right?
So it knows like I am the user that's accessing this data.
We know it's Junaid, yeah, for sure.
Perfect.
Yeah.
That's nice.
Yeah, that will leave us space
for doing some very cool stuff.
Cool, so let's ask the source here.
Let's get some good questions.
What feels, who feels this pain the most?
It's us, everyone on the team.
Yeah.
Yeah, it's everyone.
Let's just do two.
Why do you even give me like-
Yeah, I mean, this is one thing about-
You mean nothing to us.
Yeah, like.
AI, okay, so what's the why now?
What changed recently?
Team is actively building agents now
and each person is reinventing the wheel.
I think that's good.
Yeah.
Breaking the shallow task grid
and notion disconnect is causing,
that's not really a problem.
No, I think the problem is first one.
When you say read and write to notion tasks,
is the core, let me make this bigger for you guys.
Is the core, when you say read and write notion,
is the core, needs an API that agents can call
or is it that about improving what humans see
in the dashboard UI?
I think it's just the MCP.
Yeah, calling agents.
And not sure, and I mean like,
doesn't even need to be an MCP like, but-
Yeah, I'll just say API and dashboard,
agents need access and the dashboard needs to show
because I think-
Show richer tasks, yeah.
Yeah, because you will need to see,
you'll need to see the tasks being done.
I don't know, I don't think dashboard really matters
because we're just focusing on reactive, right?
So it's just about moving them forward.
Yes, the cool magic trick I want though, Lucian,
is I wanna wake up and I wanna like have this board
like we saw in the video where like,
there's like all the columns that I'm dragging.
I'm like, look at all my agents working
because what could happen is like,
here's what's crazy is like,
Janata could be like jumping in
and doing some tasks in there.
Either he signed like,
he's two or three agents are working on one part of it.
I could be working on two or three other tasks,
but like, we'd all have kind of a live view of like,
where all these things are going.
Because that central hub,
and that way it's not like we're locked into his way
or my way.
It just lets us like experiment.
That would be cool. That would be cool.
Also, it's probably also because we have the Kanban board built and it's already
linked to Notion. So like when you drag things around in the Kanban,
it updates the status in Notion.
We can easily have that just duplicate it for the task level.
We can create a, um,
I think probably the best solution would be a hook,
like a harnesses hook that would connect to Codex or to the cloud.
But the idea that is that when you pick up a task with that agent,
like when you say, Oh, I'm working on this, like, then it would, uh,
update that, that, uh, task with your, uh,
user, but also maybe identifier for the agent,
like maybe the session ID or like anything that we could identify the agents
locally, because then I can go back and see like, okay,
I worked on this task and this could even be like an array of sessions.
Like every time I connected to this task with agents,
the, we track the session that we are using,
because then I can use it to, to debug it locally. Like, Oh, okay. I,
I worked on this in this session and I can go there and see, uh,
it says metadata, metadata field or yeah.
It's not like a minimal structure, but like flexible structure I think would be
better. It's like everyone be able to.
Perfect. So we have like this agent metadata of like, uh,
history of the test and we can use it freely because I think like the next step
would be for this, like the next, next,
maybe would be to have a, uh,
VPS where you can basically in from our CLI we can decide,
Hey,
I will work on this on my local machine or I work on this on the VPS.
And when you send to the VPS,
it's basically all of them reports to the same dashboard,
meaning they will update and report the same stuff. Yeah.
Just like the mission control does,
but you can choose between running locally or on the Innovo VPS.
And we have this one place with all the security checks and everything that we
can kind of send our agents to work together,
but we can also work locally if we want to.
I think it's cool. I mean the, yeah,
I think if we focus on this little like hub part and the data in and out
problem, that's what's probably the bottleneck. Cause then like you could try,
like I said, you could do so many variations of this and it doesn't,
we have to reinvent the, we have to rebuild this central hub. Um, like,
you know, we always going to have projects, we're always going to have tasks,
we're always going to have clients. So like that interchanges can be fine. Um,
I just want to point out how smart Claude is like, Hey,
would you like me to write this to the dashboard for you?
It said, uh, but let's go back to the plan here. Um,
it said we're experiencing the AI agents. Meanwhile,
task grid is a single line to get some of the context. Your age, I agent,
I agents can't access another data without oops, sorry, I shouldn't double click.
Um, there's no audit trail, no depth to it.
Context switching over at the team juggles between notion dashboard and various
agents. Sure. We're actively adopting different workflows. Okay.
So the team members can plug into a project and task data with their own agent
without building custom integrations. It's agent to agent agnostic.
The dashboard can source a truth tasks and that syncs with notion.
All read and writes by humans or AI agents are logged with attribution so you
can see who or what changed for each task.
Projects have an LLM friendly knowledge base framing docs tasks.
We already have some of that. Um, but yeah, there's additional resources.
This would be at the, at the client level.
I don't think it would be at the project level, but maybe they could,
I guess they could have resources attached either. Yeah.
I'm going to ignore the scope. We're not standardizing stuff.
We're changing, we're not changing the task grid.
We're not messing with task grid and notion, not dealing with communication.
We'll deal with notion comments though. We'll include that. Um, you know,
we didn't really list that up here in the outcomes. Did we say that?
I think we missed that, that, um,
there's task and the comment chat needs to be part of the context. Uh,
no notion right backs for task grid. That's fine. No, you face for AI.
Yeah. This is just going to be like, um, there anything else?
The one thing I want to like kind of, uh,
elicit a bit more crispiness because it's like a bit blurry between like two
problems. One is like managing knowledge.
Um, and like the context for tasks and the other is like the bottleneck of
having like multiple tasks all at once.
And, um, some of them are like, for example, if like, we want to tackle
like the problem of bottlenecks, then we got to do like the, um, maybe a hosted
VPS that like takes multiple tasks or like a part of the task lifecycle,
just investigation, for example.
Or if like the problem of the one attack is like more knowledge management and
like allowing your local thing to talk to like the task, uh, that's like
slightly different solution space.
Does that make sense?
Totally.
I think, I think probably the second part, I think is the, in my view would
be, is the one that needs to focus first, like on organizing the data and
making it accessible to our local workflows, because then we will use it
and we will find the best ways to use it.
And then we can probably like streamline this into a, uh, shared space in a VPS,
for instance, in a set of a cloud or codex agents that are always on.
And you can just say, okay, uh, spawn this agent, which would basically start a
cloud session with that agent context loaded on the VPS.
And then you pick a task and you start a run.
And what that will do is you pick the task from our, from our knowledge base.
And the run is basically what we see in a single terminal window is like the whole
stream of work and all the two colleagues that will represent a run on our server.
And I think that's kind of, it's not a complicated structure to build.
I think like, to be honest, probably we just need a script where when you spawn a
agent, it creates its own workspace.
It has its own safe credentials, so it doesn't, it can't like merge to the, to
the branch or anything like that.
We can create this safe, uh, setup.
It can even like be, uh, its own container, like inside the VPS.
Um, and.
We can, that's a good question.
Like, are we, uh, what is the, we need almost need like a, and like a skill or a
file that all agents will need to have context of like where stuff is my, every
time I post something, please leave a comment when work is like, do we need
something where it's like, as if we're training the employee handbook of like,
Hey, all these army of agents that are about to show up, like we have standards.
Like when you change this, you need to leave a comment in notion, or if you do
this, like make that like when, um, I don't know, just, just to make sure that
we're getting stuff in and out.
Like it doesn't start working on the task and forget to change the status.
Like it needs to know some of the rules.
So the best way I know to force this is to do something like they are doing with
this, uh, GitHub, you, you should try this.
It's very interesting.
It has comments like map your code base and has specific sequences
of comments that it follows.
So if you do, we can do something like we can start with face slash framing and it
will call automatically days like shaping when we finished.
And then it will start working on it on parallel.
Like we can, um, make, uh, chain, uh, calls of commands and workflows that are
running on the harnesses on there.
And you can, I think this one is just for cloud code, or I don't know if it's
updated for codex already, but, uh, it making one for codex, just like translating
to the API that codex use.
So it's very, you, you basically place your harnesses, your harness on a guardrail,
like on a specific flow that it has always to follow.
So we can adopt like, Oh, if I'm working on a novel project, then we will be using
the, uh, in oval, uh, GSD, which would follow our, our, uh, workflow and hook by
the end where it's always update on the dashboard.
Like, that's what we can do.
Like it was a day to draw a sketch from there.
It will know where things is.
But is, is it, uh, where does it pull it?
Like, where is it stored?
Is it stored in the dashboard and it pulls it down?
No, it creates all locally.
When you run, uh, the command, when you install this, this, uh, tool, it creates
like on the dot, it sets up your dot cloud, uh, locally.
So you can get it from the, it's got to have somewhere it's pulling it from
centrally, it's a, it's a, it's a, um, I think it's a node package, like when you
install it, like it's all into the dashboard.
So we put it on our dashboard.
Uh, no, I mean, this, uh, I'm, uh, this one, the, the, this, uh, Gatsby.
done one it's it's all it doesn't it it's all self-contained so all the when you run the node
command to install this it will install all the sequence of commands and everything on your cloud
files so it's basically a way of placing it on on rails we can have this uh in in our dashboard for
our solution if you want but we need we need a place where we can like adjust that slightly just
so that we're all picking from the same i mean because i think what you're saying is like this
is a good framework just like that standardizes it but we may want to just like tweak it so
there's some rules yeah we need our own version of it like that's what i mean that this is just
a reference of how we can implement this in a way that our agents like our innoval agents
will always know how to use the novel tools this can be done in a simpler way using like just
cloud.md or agents.md and a set of rules and stuff but i think this tool is a lot more
you place more strictly uh you have to follow it the model has to follow it more closely
it's it's more um yeah like we could have like a novo framer like framing piece and then like
drive debugger on a novo like transcoder debugger like you know we could have specific things that
can be shared across projects and it's very easy to install because you just install at the project
level so it doesn't mess with all your cloud setup it just installs at that project so it creates a
cloud at the project level and inside that project has all the setup with you need with
all the agents with all the workflows with all the commands and we would just i'm understanding
it's just committed at the project level because we're not managing like hundreds we have like
you know we might get like a new custom client every like few months and then we just like
kind of copy the is it the good like skills you know it's because the repo right it's going to
like the it would be at the regular level yeah i got you now but i've been doing this but like
if we have a command line interface i want to step back to something else here um i agree like uh
janelle you answered my question i was wondering like you know do we do kind of parallelization
or knowledge management and i think knowledge management management makes a lot of sense
because it's like the foundation also that could be like an outcome it's a foundation for us to
have our vps that like intelligently does stuff but like for this project it's it would be easy
to get carried away so like how would we know that we're done you know like where would we
kind of say like oh yes we fit in like solve the knowledge management agent connection piece
uh in my right an outcome would be like you could you could basically kick off a session
pull down all the context um for a particular task or something or in my flow would be like
you'd you'd pull up like a few tasks and like you know have it maybe process it to to like
plan those tasks and then you could fire off or execute them or whatever i don't know if i want
to like prescribe the the flow too much but i would say like i don't have to go to notion and
then the dashboard and then like some something in slack like ideally we're kind of the the
habit change behavior here would have us to have to be like keeping a lot of notes in in notion
comments which we kind of do already um but like if we wanted to weigh in on stuff or copy a bunch
of text we could just paste it into the notion comments for more context but that's how i would
think this is done when like bridging can spin up a terminal and like pull down a task work on it
kick it back in a very simple model now you could then go in multi like agent mode with like three
or four of these things running at the same time or like john was saying like i have something
that's running on my bps this is running locally this is running wherever um that's how i would
kind of see this as being done yeah i like that that that now becomes like extremely sharp because
we're kind of like shifting like you do like everything that you're doing and you keep
developing your own workflow but just the only connection you don't have to go to notion anymore
you can just like tell your your agent like do the investigation yourself and then write back
like automatically but it's not whatever uh janata's drawing so i'm curious what he's drawing
because the dotion projects and tasks would be like underneath the dashboard but what do you
think uh yeah like they are basically the yeah it's access the same the same information but like
It's like this, so.
But then the question becomes like,
why not just like Notion MCP?
Directly, yeah, that's what I'm,
like, what are we gaining from this extra layer, right?
What are we integrating to this CLI to make it easier to?
A Notion doesn't actually work,
but what I've seen, like, it's not very fast for one,
like, getting data in and out.
And I've, and the MCP's not great.
I think, because one thing,
if you can go through the dashboard,
we can link in those client knowledge stuff.
We could link in, like, general things about the task,
like time tracking.
We could link, you know,
it could have different questions or context, comments.
I mean, you'd have the comments in the Notion part,
but I also, if we're building something kind of the future,
I'd love the idea of it
not being totally locked in on Notion.
I do think we're gonna outgrow Notion at some point
with this.
At some point, we'll be writing projects and tasks
directly to the super base,
but the dashboard and just working at it there,
we may not need the Notion view.
I am using Notion-
We can be tool agnostic then.
Yeah, I mean, I don't wanna, like,
be, like, scared of it and not use it,
but we could,
yeah, I mean, the only other thing,
like, if you wanna sort of draw it,
there is that happening,
but there's, you know, toggles in here.
And there's also,
you know, we also have, like,
Mercury and, like, all the payment information as well,
so you can kind of see.
Like, it'd be cool.
You could actually ask it, like,
like, how much am I gonna make this month?
That's cool.
No, that's gonna be a problem,
because it may not be,
I'm gonna go and, like, ask the,
ask what-
Yeah, because, like, I can,
it's difficult because, like,
I can ask how much solution we'll make this month.
Well, it won't, because technically you'll have a,
you'll have your own token,
so we wouldn't know who it is,
so it wouldn't be quite that hard, but-
Yeah, but then the security,
the access level of this list-
The next thing in the future, though,
this is where it's gonna get powerful,
is, you know, then we,
in the future, we would add Slack.
In the future, we would add, like, email.
You know, that's where the magic will start to happen.
So, yeah, because it's kind of simple.
Yeah, right now, we could just totally-
In addition to this,
even, like, agents and workflows would be shared, like, here.
Would be shared, like-
True.
Like, I can see, yeah.
No, not, like, agents.
I'm running, like, agents templates, let's say,
that you can use, but, like,
they are shared between the team.
Or eventually, even, like, runtime, like-
Yeah.
It's, like, Innovo owned, you know, Innovo's VPS.
I just want one screen where it's, like,
a group of all Lucian's bots running,
and Gennady's, and my, like, everybody's, like,
you know, people-
That's, yeah, we are-
There's 30 agents running right now.
Yesterday, I was able to make this working, like,
our-
It now knows where, when I have a diamond
running on my machine,
and I can just, like, do a slash slash local,
or slash slash remote,
and it will decide whether it will run the task
on my local or my remote.
So it's-
And I was, like, man, that's so cool.
And we are-
We literally can, in a couple months,
probably, like, really make that thing
where we can have this dashboard,
and can be even animated with my agents
going to the Lucian agents,
and, like, handling some stuff,
and we can be, like, watching.
It's awesome.
That's funny.
Great.
Cool, I know we ran over time, so this is good, though.
I know we, like-
We kind of went down this yesterday on the call,
and then we-
It was good to kind of close it up
and to have something framed.
But, yeah, let's keep working on it.
I think this is exciting times.
I just-
What I wanted to do was make sure-
I was starting to set up some of this stuff
to make it all sync,
but I didn't want us to all-
It sounds like we're one missing piece away,
which is this Notion task issue.
And then the other thing that, again, with Notion,
like, I think with the database would be good,
is having that crazy, like, detailed activity log
of, like, Luchans, like, terminaled on this thing
on this date, changed this project,
did this thing, committed these files to the repo.
I think the other thing we're out of scope here
is there's no connection between the Novo dashboard
and the repo.
Like, you're just gonna have to tell the agent, like,
this is the repo we're working on.
I think, like, some of those things, I think,
are a little, like, gray area we didn't really talk about,
but those are things I'm assuming.
If we didn't talk about it, it's not on the list.
So sweet nice nice awesome guys
Sweet alright guys
Good stuff