Okay so earlier today the Entropic employees basically vibe coded a little too hard
and accidentally released what is essentially the source code for Cloud Code. Now over the last few
hours Twitter has been blowing up because people have been dissecting the source code in all sorts
of ways but in this video I want to go through all the upcoming features in Cloud Code as evident
from the source code itself. Now do bear in mind they may or may not release these features and
the features may be different by the time they're released but this is the present state as in the
source code itself. Now first of all we have a upcoming proactive mode in Cloud Code. Up until
now Cloud Code has been reactive whereby you give it a task and then it will basically do it for you
and then wait for your next input but what they're doing here is they're basically having Cloud Code
run around the clock so there's like an interval and it basically decides are there any tasks that
need to be done it explores the code base and then it will do the task and then it will go back to
sleep until there's another task that it deems that is worth doing. So they're kind of shifting
away from this reactive mode where Cloud Code only waits for your input to proactive mode where
it's working around the clock for you. So you may have Cloud Code hooked up to Slack via channels
and then it sees a Slack message and decides to implement it then and there it notices any
to-dos in the comments of your code base it just does them it sees that a new file has been added
so it like reviews those new files it may notice some tests are not passing and then it will
automatically fix them. Basically we will find that Cloud Code will soon be much more active
in doing tasks for us that need to be done and I do have a previous video about this where I
basically talked about how Anthropic are heading towards a software factory model that you can
watch as well. So next up we're going to have some background skill improvement added whereby every
five user messages Cloud Code will basically do some analysis behind the scenes of those user
messages and ask like what should be changed about the skill based on what the user said.
So for example if you triggered a skill and then you corrected it and said no actually use this
other thing instead then Cloud Code will automatically update the skill in the background and maybe they
will add some kind of review feature at the end being like hey I noticed the skill needs updating
in this particular way but I think this is a much better approach going forward whereby a lot of
people make a skill like really well the first time and then it slowly falls out of date and
they forget to update it. So by having background agents that automatically improve our skills for
us can lead to better results in the long term. Next up we're gonna have an away summary whereby
Cloud Code will automatically see if the terminal isn't focused and if you switch away from the
terminal to another program for more than five minutes and then come back to terminal it will
automatically tell you what it did whilst you were away with a nice summary. So this can be handy
because then when you come back you don't have to scroll up through the session history to find out
what Cloud Code did whilst you are away because it will automatically tell you. Next up we will have
a coordinator mode whereby currently right now in Cloud Code you have a single agent mode where
So most of the time the default behavior of Cloud Code is it will automatically read run
commands and write files. It may occasionally delegate things to sub-agents. Now essentially
in a coordinator mode you will find that Cloud will basically not do any work with inside of
the main context window and it will delegate it amongst a team of sub-agents. So essentially Cloud
Code will never touch your codebase directly it will always touch it via a kind of worker sub-agent.
In coordinator mode we may be in one of four phases. The first phase could be a research
phase whereby Cloud will automatically decide to spin up parallel workers which will read
through the codebase kind of like the planning mode how it does currently to understand how
things work and fit together. Then there will be a synthesis whereby the coordinator will review
all the reports from the researchers to identify gaps and figure out where there are contradictions
and stuff like that and then any implementation that needs to be done will be delegated to task
specific sub-agents. And then there will be more sub-agents that kind of do validation and
verification via tests. Now you don't actually have to wait until the coordinator mode is released
because you can essentially do this with a good Cloud.nd file and sub-agent teams. But it seems
that the Enfropic team basically discovered that this is a good approach and coincidentally I also
discovered that this is a good approach which I talked about in my Cloud Code masterclass
about one month ago. So if you do want to stay ahead in terms of Cloud Code then this is the
best place to do so. A lot of people from some of the world's biggest companies have taken this
and have found it really useful and many of them have become the best Cloud Code users at their
companies. You will find that many of the ideas that I talk about within this masterclass have
become mainstream many months later. So if you want to stay ahead on the curve and be like learning
the best Cloud Code practices before pretty much anyone else then this is the best place to do so.
Anyways they will also be adding a verification agent. So the default behavior of Cloud Code is
it's kind of like an optimistic developer where it kind of assumes that something works. It runs
like basic and shallow tests. It reads a code that it wrote itself and is like oh this obviously works
because I wrote it. But now Cloud Code is adding an adversarial agent which will have a pessimistic
approach and it will default assume that anything breaks and try to actively break the code. And to
show you just how early I am when it comes to this stuff I was talking about this concept seven
months ago in my video on how I used Codex Eli to fix Cloud Code. And then seven months later OpenAI
released a Codex plugin for Cloud Code so you can automate the process that I was talking about
seven months ago. So yeah if you do want to stay ahead on the curve then my Cloud Code masterclass
is the best place to do so because the ideas that I talk about here become mainstream many months
later. But I actually don't know how much of an impact this would have because it's likely going
to be using the exact same model except with a different system prompt to try and find those
problems. But I find that it's better to use a completely different model like GPT 5.4 because
it can find much more mistakes. So even though they're adding this I don't think it will be as
good as using a different model. But I think one difference with this verification agent is that it
basically has a bunch of strategies to figure out and find problems. So it can spin up a development
server and then do like browser automation for UI testing. It will run curl requests to like
different endpoints to make sure the API is robust. It will try to reproduce the bug itself first
before trying to fix it. And it will do stuff like making sure database migrations are reversible.
Cloud Code will also be adding token budgets as a way of forcing deep work. So currently right now
Cloud Code will just decide like okay I think I'm done with this and then give you a pretty
simple answer. And it may have only used about three four thousand tokens to come up with that
answer for you. But you may have a task which you want Cloud Code to do a really big deep dive into
like doing really deep research online or in a complicated code base for example.
In this case you can specify a token budget. So you can tell Cloud Code okay we got to use
at least 500,000 tokens here. So essentially you're telling it to spend a minimum dollar
amount of compute. And then Cloud will decide to stop once it either reaches a budget threshold
which is 90% of the token budget you assign to it. So if you assign a token budget of 1 million
and it reached 900,000 then it would stop. And secondly it would stop when it thinks that
progress is slowing down. And I think internally they're defined like if the last three continuations
where Cloud Code just keeps continuing returns less than 500 tokens but maybe they will adjust
this in some way. But essentially you now have a hard minimum whereby if you have a really
complicated task and you want the best possible answer from Cloud Code you can define it to use
a minimum number of tokens. And I think the interesting meta point here is that Entropiq
basically making it easier for us to use even more tokens with token budgets and the proactive
thing that I mentioned earlier. Next up if they move ahead with this there will be a ultra plan
mode where basically Cloud will automatically connect to a remote session on the Cloud Code
runtime and then automatically upload your repo onto it. And then the Cloud Code runtime will be
doing a deep plan and they may have some kind of like internal system prompt for this or something
like that or deep planning architecture and it has like a timeout of 30 minutes maximum. Then your
local session of Cloud Code will automatically check the Cloud Code runtime, the cloud version
every three seconds to make sure that everything has been done. And if it has been done then you
can view the plan on cloud.ai. If you reject it then it will go back into runtime. If you accept
it then you can either have the plan executed locally on your terminal or have the plan
executed remotely on the Cloud Code runtime. I'm really curious what kind of system prompt
and architecture they will use for this brand new ultra planning mode but I imagine it will be kind
of hidden from us because it will be running on their own cloud version instead. Anyways they will
also be adding a templating job system inside of Cloud Code. So right now all your conversations
with Cloud Code are ephemeral whereby you give it a task, it replies and then you basically go back
and forth and tomorrow you may end up doing the exact same thing. So what this persistent job
template system will basically do is Cloud will automatically identify when something needs to be
turned into a job and then it will turn it into a job template for you. So this means that tomorrow
when you're doing a very similar task then you can basically reuse the same template that Cloud
Code automatically made for you yesterday. And then there will be a bunch of commands whereby
you could just do cloud new and then do the job name like you'd probably be able to do like cloud
new deployed to production or something like that. And then you will be able to do cloud list to
basically see which jobs are in progress and then reply to individual jobs without actually having
to open up the conversation for each of those jobs. So it kind of feels like they're turning
this part of Cloud Code with the templating and job thing into a task management system of sorts.
Next up it seems that they will be adding push notifications as well whereby it will automatically
be able to send you notifications probably via the Cloud app on your phone. So when a task has
been completed on the cloud then it would send you a notification there or on your computer if it's
running in a proactive mode. So I think this is really handy for proactive mode whereby if Cloud
is running proactively I kind of want to get a regular like understanding via notifications for
what exactly it's doing and what it's done so far today. We will also have real-time PR watching
with GitHub webhook subscriptions whereby if you make a brand new PR then another team member replies
to PR or another agent like a code review agent replies to it then Cloud will automatically be
notified. Okay we have a brand new reply let's look at it and check it out. Next up we will have the
option of context preserving sub-agents. Now when you spawn up a sub-agent the sub-agent doesn't
have any prior context of the conversation except for the system prompt that Cloud Code gave it.
But if you are a heavy user of Cloud Code then you may find in certain situations when Cloud
Code decided to spin up a sub-agent then like even though the system prompt contained a lot
of information it didn't contain enough information for the sub-agent to do a good job.
This is kind of like a double-sided sword whereby a sub-agent can bring a brand new perspective
because it's not distracted by all the context that's been accumulated so far but in other cases
it can actually do a worse job because it didn't have all the context. So essentially what Cloud
Code will be able to do is using the same prompt cache so far it can spin up a sub-agent with all
the prior history in the conversation so far and then have it do a task or have many of them running
in parallel. So you could have the entire conversation so far be divided amongst five
parallel sub-agents that are all forked from the main conversation doing some research some
hypothesis or whatever and then that feeds back into main session. Next up we will have some kind
team memory as well. So right now there is auto memory inside of Cloud Code but that's unfortunately
individual memory that only exists at the local level instead which kind of means that knowledge
is siloed and shared context may be outdated or drifting apart in some way. But essentially what
Cloud Code will be doing is adding a brand new directory for projects which is like memory
slash team. I don't know how this will be synced it may be synced in the background automatically
via like cloud.ai or something if you're part of a team plan but essentially this now becomes
a living document knowledge base that every team member's cloud contributes to and benefits from.
We will also have some kind of bring your own computes for Cloud Code. So if you use Cloud Code
the web version you know that you can define environments set secrets and a bunch of other
things as well and all of that runs on Entropiq servers. But it seems that what the Cloud Code
team will be providing is a docker image whereby you can install it on your own servers instead
and then in your own server you can set your environment variables mcp configs and stuff
like that and then when you send a task to Cloud Code to the cloud then instead of running on
Entropiq servers it will run on your own servers. It will still of course make requests to the
Entropiq API so that has to be whitelisted but everything else will be happening on your own
servers instead. So this matters more for enterprise whereby you have secure isolation
and you would have like parallel sub-agents that can spin up really quickly on your own
infrastructure instead of being bottlenecked by Entropiq's infrastructure instead.
Next up we will have a brand new concept known as context collapse. So right now there's a
problem with auto-compact or just doing slash compact whereby your entire session history will
go to Cloud like their servers it will say summarize this conversation so far and then
that will be passed into a new session. Now this means a lot of like important things can be lost
and a lot of non-important things can stay. So essentially what Cloud is now going to do
is have a reversible context collapse whereby things will have a different risk score assigned
to them. So really long tool output for example would have a low risk score assigned to it and
would be summarized and replaced in like line in the conversation and something like a key decision
that you made would have a high risk score assigned to it. So you'd have different blocks in
your conversation with different risk scores and when Cloud Code automatically sees that okay our
context window is being filled up then anything that is a low risk it will replace with the
summary instead. But that will still be reversible so I think that if Cloud Code still decided it
needed to see the full message of that chunk instead of the summary then it would be able to
do so in some kind of way. You can also sync your local version of Cloud Code to Cloud.ai and have
that be a read-only mode. So this matters because like let's say for example you were giving a
presentation and you wanted everyone to see your local instance of Cloud Code you could just give
them a URL to like Cloud.ai and then they could see it but not actually make any changes. So this
is really great for demos or monitoring someone else's instance of Cloud Code or showing a team
like member to get feedback or something like that for how you're working with Cloud Code. I imagine
that this will also be used for technical interviews as well because many companies
are now interviewing for how good someone is at using Cloud Code these days. And of course remember
if you want to get better at using Cloud Code then there is my masterclass for doing exactly that.
So right now switching between the terminal and Cloud Code is like a bit tedious but it seems
that what they will do is turn it into a single shortcode whereby you just press it, it switches
the terminal, you press it again it switches back to Cloud Code. Cloud Code will also make it easier
to launch and view background sessions as well. So you can launch a background session by just
doing like cloud dash dash bg and then give it a command over here and then it will basically run
headless on your computer or your server. Then you can do cloud list to see the background sessions,
show the logs of any of them, attach to a particular background session or decide to kill it
instead. So I guess a command will kind of be like cloud ps kind of like docker ps, cloud logs, cloud
attach and cloud kill. Next up we will have some kind of setting sync whereby your settings on one
machine will automatically be encrypted and saved on entropic servers and then decrypted onto
another device or something like that. So if you change your config on one device then that should
carry over to other devices and over remote instances of Cloud Code, any memories that you
have, key bindings, permissions and so forth. Now there is also an easter egg feature that they will
be releasing tomorrow for April Fools, so if you don't want a spoiler then like end the video here
but if you are interested then I will be explaining it right now. So they will be adding some kind of
tomorrow whereby essentially your user id will be turned into a hash and then you will be
automatically assigned a companion of sorts, so it could be like a duck, goose, cat, dragon, robot,
whatever. And people will have different ones with different rarities attached to them. Anyways I
thought this was really interesting, do bear in mind that they may not decide to release all of
these features and by the time they are released they may actually work differently to how described
but when the final versions of those features are released then I will be making actual videos about
them and if you do want to stay updated with that then do subscribe to the channel because
I do make the best Cloud Code videos here on YouTube.