[00:13] So, thank you so much for showing up at
[00:15] 8:00 in the morning and it means more
[00:18] because you were you are all in Vegas,
[00:20] right? So, you must have been partying.
[00:22] So, what are we going to talk about,
[00:24] right? So, agentic shift in software
[00:26] development life cycle. So from the time
[00:29] you have been attending Google cloud
[00:31] next for the last two days you must have
[00:33] heard so much about agents right and AI
[00:37] it's all about AI and agents right
[00:38] everywhere so we are going to talk about
[00:41] the adoption trends in AI how do you
[00:45] manage multiple agents together when
[00:48] they work in parallel and more
[00:50] importantly how do you take the code
[00:53] that you have built using AI to
[00:56] production right And then we will wrap
[00:58] it up with a special session about the
[01:01] success of AI initiatives with in
[01:05] software development life cycle at web
[01:07] pro. Uh my name is Aluk Shivasto. I'm a
[01:11] product manager in Google cloud. I will
[01:13] be joined by Rakkesh Duper who is a
[01:15] director of outbound product management
[01:17] in Google. And then we have Sachin
[01:20] Chandra, global head of Google
[01:22] partnership at Webpro.
[01:25] All right. So
[01:28] let me ask with a raise of hands because
[01:30] we don't have a poll here. How many of
[01:33] you are using AI actively in your work?
[01:36] It can be software development or
[01:38] something else
[01:40] right pretty much everyone right and
[01:42] that's exactly what we have seen here
[01:44] right so Dora
[01:46] DevOps uh research assessment they run
[01:49] an yearly survey right so they talk to
[01:52] thousands of developers across the globe
[01:54] not just within Google but across the
[01:56] globe across different companies and
[01:58] they talk to the developers in a
[02:00] qualitative manner which involves
[02:02] hundreds of hours of qualitative data so
[02:05] we have seen that almost 90% of the
[02:08] people are using AI at work right and
[02:11] where is AI getting adopted so as you
[02:14] can see on this slide for writing new
[02:17] code almost 70% of developers of the
[02:22] employees that were surveyed are using
[02:25] AI right so which is what you call as
[02:28] green field development right we'll talk
[02:31] about both green field and brownfield in
[02:33] our session as we go forward
[02:35] Right. So one of the key findings of
[02:38] Dora is that the primary role of AI in
[02:42] software development is that of an
[02:44] amplifier. Right? So what does amplifier
[02:46] do? It boosts the signal. Right? As in
[02:50] musical devices, electronic devices. So
[02:52] in case of AI if your context is clean
[02:56] and if it is reasonable enough then the
[02:59] same goodness will flow in will spread
[03:02] into your entire workspace or code
[03:05] space. But if my intent and my context
[03:08] is lacking somewhere then the same mess
[03:12] will flow in or spread into my entire
[03:14] workspace or code space. Yeah. So how
[03:18] many of you read uh Sundar Pichai's blog
[03:22] yesterday right so uh we have been
[03:25] tracking the adoption of AI for writing
[03:28] new code within Google right from the
[03:30] last two years and this this number was
[03:34] a little more than 12 months ago the
[03:36] number was around 25% and then it was
[03:38] around 54% last fall and now we are at
[03:42] 75% where all the new code at Google is
[03:46] getting generated with AI. Yeah. And why
[03:49] is it happening? Why it didn't happen
[03:51] earlier? Right? Because
[03:53] one and a half two years back if you
[03:55] recall with AI things are moving so
[03:57] fast, right? So one and a half, two
[03:59] years appears like a long time. But we
[04:01] were in a stage where we were doing uh
[04:04] retrieving right and from retrieving now
[04:08] we have evolved to reasoning. We have
[04:10] evolved from prompt and response to plan
[04:14] and execute. And with agents coming in,
[04:17] you are not just typing a prompt and
[04:19] getting a response and then doing an
[04:21] iterative prompting, right? With agents
[04:23] coming into a picture, you want to build
[04:25] let's say a banking web app, right? Or
[04:28] you want to modernize your code. You
[04:30] provide a prompt. You get a response
[04:33] which asks you what kind of programming
[04:34] language you want to use, what kind of
[04:37] layout, right? Is are these requirements
[04:39] looking okay to you? And that's what we
[04:41] call as humans in the loop, right? We
[04:44] are not yet there. in terms of uh think
[04:47] about a completely FSD or a fully
[04:51] self-driving vehicle. So we are not yet
[04:53] there right but in some form we are
[04:55] there. For example, if you look at the
[04:57] the agentic code review agents that are
[04:59] available, you go to uh GitHub, download
[05:03] the the code review agent which is
[05:05] provided by Gemini code assist and then
[05:08] the moment you create your pull request,
[05:11] the agent kicks in, right? Even then in
[05:13] some forms you will still need human in
[05:15] the loop.
[05:18] Yep. So with so many agents everywhere,
[05:21] what is bound to happen? some form of
[05:24] conflict, right? Some form of agents
[05:27] stepping into each other's territory. So
[05:31] what's the answer, right? So we will be
[05:33] talking about a very recent uh uh
[05:37] framework and a test bed orchestrator
[05:41] that is built by one of the Googler
[05:43] right so we'll get there but before we
[05:45] go there let's look at what kind of
[05:47] challenges we face when you have multi-
[05:51] agents in a system first and foremost is
[05:55] the isolation and security so I build an
[05:58] agent it can be let's say a custom agent
[06:01] and then there are some out ofthe-box
[06:03] agents provided by Google, they can be
[06:05] provided by somebody else and then you
[06:07] have your own development, your own
[06:10] workspace, right? So the agents can go
[06:13] rogue and even end up doing something
[06:15] like RM minus RF, right? So that's the
[06:17] the adverse kind of uh or the most
[06:20] adverse situation that can happen. But
[06:22] the agents can also intermingle and
[06:24] create uh conflicting actions, right?
[06:27] And then so many agents so many models
[06:31] so there are specific agents which are
[06:35] tied to specific models right so uh they
[06:38] are hardbound and there is a tight
[06:40] coupling between the agents and models
[06:43] right so these are some of the
[06:44] challenges so that's where we talk about
[06:49] the the latest and greatest solution
[06:52] which we call as can right so this is
[06:55] open-source test bed for orchestrating
[06:57] AI agents, right? How do we orchestrate
[07:00] it? We will see all of that in a demo,
[07:02] right? But uh at a higher level or uh at
[07:06] a philosophical level, think about it as
[07:09] a hypervisor of agents, right?
[07:11] Hypervisor, we are all aware HyperV,
[07:13] VMware, right? So there is a a a
[07:16] solution and that hypervisor manages a
[07:20] fleet of virtual machines under which
[07:23] you have different operating systems,
[07:25] different applications. Now think about
[07:28] can as hypervisor of agents which means
[07:30] that now you are managing a a fleet of
[07:35] agents right and all these agents are
[07:38] running in isolated environment in the
[07:41] form of containers in a fully secure
[07:44] manner.
[07:46] So let's see. So I'm in action. Can the
[07:50] back end team please help me switch to
[07:51] the my local machine because this is a
[07:55] demo and then I may want to skip to
[07:56] certain sections. Thank you.
[08:06] All right.
[08:08] Yeah.
[08:13] So this is my local environment.
[08:17] So I have configured cyan already here.
[08:20] You can see that when I give the command
[08:22] c this beautiful as sky characters they
[08:25] appear right with the version and
[08:27] everything. So it is available on github
[08:30] you can go download install pretty easy
[08:33] like maybe in 15 minutes you will be up
[08:35] and running.
[08:38] Yeah. So it describes what Cheyenne is
[08:40] containerbased orchestration tool for
[08:42] managing concurrent LLM agents
[08:46] and then you are able to do parallel
[08:48] execution of multiple agents right so we
[08:52] were talking about the support of
[08:55] multiple LLMs right so let's look at how
[08:58] it looks
[09:00] so I give this command
[09:03] can
[09:05] harness config
[09:09] Yep. So you are seeing not just Google's
[09:13] Gemini products, right? You are not only
[09:15] seeing the Gemini models.
[09:19] So there is there is clot, codeex, open
[09:21] code, right? And again on the right hand
[09:24] side you see something called as image.
[09:27] So these are the container images that
[09:29] we will use when we try to actually
[09:31] build an agent using can right. But scan
[09:36] uh I'll reemphasize this is not just
[09:38] about doing a coding task or software
[09:42] development task using AI right that you
[09:44] can do even without scan right so it's
[09:46] about a spe creating a specific
[09:49] container where your agent is running in
[09:52] a secure manner right so let's see what
[09:54] happens next so this is where
[09:59] we'll be giving this command
[10:04] yeah so we saying create a Python script
[10:07] doing some Faboni work but then we are
[10:10] also calling Gemini and we are calling
[10:13] that specific container image that was
[10:15] mapped to Gemini when we listed all the
[10:17] models that are supported by scan yeah
[10:20] so now what you see here is a T-max
[10:23] session right so for those of you who
[10:26] may not be aware with T-max so this is
[10:28] like when you are on your terminal but
[10:30] you want to create another one right a
[10:33] sub terminal within your terminal
[10:34] terminal where specific processes or
[10:36] programs are running. That's what cyan
[10:39] is doing here. Right? So that there is
[10:41] no impact to your local terminal. Right?
[10:44] We will also see that you can even
[10:45] detach the the agent that I have
[10:49] spawned. Right? Detach doesn't mean that
[10:51] it will stop and running. Right? So it
[10:54] will continue to run and then you can
[10:56] come back to your terminal and do your
[10:58] other work.
[11:16] Yeah. So this is interesting when we see
[11:20] get work work tree list right so how
[11:22] many of you like most of you are using
[11:24] get if you are into software development
[11:27] so I talked about isolation right and
[11:30] that's what I want to highlight here let
[11:32] me even increase the font a bit yeah so
[11:36] you are seeing that I'm giving workree
[11:38] list and there is this directory from
[11:42] where I launched in right but the agent
[11:45] which is running is has created another
[11:49] path from where it is doing its work.
[11:52] Right? We gave a prompt to create a
[11:54] script for printing the first 10
[11:57] Fabernaki numbers. Right? So, but it is
[12:00] not in my main. So, so which means that
[12:03] even if my agent goes rogue or even if
[12:07] my agent does something unexpected, it
[12:10] will in no way impact the work that I'm
[12:13] doing in my main directory.
[12:17] Yeah. Let's move further.
[12:27] How many of you use products like Gemini
[12:30] CLI?
[12:32] A lot of you. Okay, it's pretty good.
[12:35] Yeah. So, yeah.
[12:38] uh you can go to GitHub and just search
[12:41] for cyan and then uh you can deploy it
[12:43] on your local machine. You may need uh
[12:46] an environment like docker right even I
[12:48] had got docker here on my environment.
[12:50] The reason why I'm not able to do a live
[12:52] demo because I got a notification from
[12:53] our security team saying that hey you
[12:55] cannot have docker running because of
[12:57] certain conditions. So I had to
[12:59] uninstall it and that's why you see a
[13:01] recorded demo. Now
[13:05] what we are seeing here is
[13:09] let me just proceed here.
[13:12] Yeah.
[13:15] So my agent was running right. It is
[13:19] detached and now I when I'm doing a
[13:21] listing as I talked about T-Max right?
[13:24] So I'm opening two different terminals
[13:25] but you can do it on the same terminal
[13:27] also. So you are listing and this is the
[13:30] the the
[13:32] py file is exactly what we wanted it to
[13:35] to create right at the end of the demo
[13:37] we will see how good is that file and
[13:39] based on that we can accept it or reject
[13:41] it.
[13:53] So we are going to stop the demo agent
[13:57] right
[14:01] and then we will see what is the impact
[14:02] of stopping that demo agent right are
[14:05] our directories there right because when
[14:07] you do let's say some of you might have
[14:09] tried your hands with wipe coding right
[14:10] you do wipe coding and then uh it is not
[14:14] ephemeral right because it is there in
[14:17] the in your window and then it goes away
[14:19] right so let's see the ephemerality or
[14:21] non-ephemererality of can.
[14:25] So I have stopped the agent and then
[14:27] I'll go back to the terminal and we will
[14:30] see if the the work that it has done is
[14:33] still showing up or not.
[14:38] Yeah. So I do a cat of that file. It is
[14:42] all there while my agent has already
[14:44] stopped running.
[14:52] Okay. Uh and from here on the developer
[14:55] can accept the change and you can even
[14:56] merge this right. Not even you will
[14:59] obviously merge the the the the work
[15:01] that is done by the agent into your main
[15:04] branch. Can we please move back to the
[15:06] main slides? Yeah.
[15:12] All right. So I showed you a single
[15:15] agent, right? But the intent was to show
[15:18] how it can run in an isolated secure
[15:20] environment without impacting your local
[15:22] workspace. Right? But can be a test
[15:25] batch for multi- aent orchestration
[15:27] scenarios. So without getting into all
[15:29] the the colors that you are seeing here,
[15:31] right? So what is this depicting that a
[15:34] single agent can spawn into multiple
[15:37] agents, right? Or multiple agents can
[15:39] converge into single agent, right? Or
[15:41] they can diverge into doing something.
[15:44] All right? So every agent can have a sub
[15:47] agent and then it can have its own task
[15:49] right but irrespective of the scenario
[15:51] irrespective of the number of agents the
[15:53] way they are spawning irrespective of
[15:55] the the model you will be able to
[15:57] orchestrate all of them using scan.
[16:00] Yeah. So some of the benefits and key
[16:02] features which were already very obvious
[16:04] when we were doing the demo but I'll
[16:06] summarize it here. So you are able to
[16:09] run multiple agents in parallel uh
[16:12] independent of each other. that's uh
[16:15] that happens with the help of the
[16:17] container technology right and something
[16:20] very important I want to call out again
[16:22] that this is harness agnostic so it is
[16:25] an open-source framework right you want
[16:27] to give it a try again go to GitHub get
[16:30] it up and running in 15 minutes and it
[16:33] is open source right so it is publicly
[16:35] available for adoption and it's uh it's
[16:38] based on the communitydriven
[16:40] contribution
[16:42] right so I'll call Rakkesh on the stage
[16:45] to talk about all the work that agents
[16:48] do, right? How do you take them into
[16:49] production? Thank you, Rakkesh.
[16:51] >> Thank you. Alo,
[16:56] thank you. Alo,
[16:58] so how many of you here write code just
[17:02] to leave it on your desktop and never
[17:04] push it into production? That's a
[17:05] rhetorical. Okay,
[17:08] I did not expect that answer.
[17:11] Most of the work that people are doing
[17:14] um is to solve a problem. You write
[17:17] code, you want to push it into
[17:19] production, whether it's for your own
[17:21] individual use or whether it's for your
[17:23] enterprise or business or whatever. And
[17:26] like Aloc was talking about, you know,
[17:28] there's multiple ways to use agents to
[17:32] write code, whether it's through the CLI
[17:34] where you're interacting with it or it's
[17:36] through orchestrating multiple agents.
[17:39] The net effect of all of these things is
[17:42] that the velocity of developing code has
[17:45] gone way up. The productivity of
[17:47] developers has gone way up. But at the
[17:49] same time, the velocity is impacted by
[17:53] how the code actually makes it to
[17:54] production. And there are bottlenecks in
[17:56] that rest of the pipeline. Then what's
[17:58] the point of writing all of this code if
[18:00] it cannot make it to production. So what
[18:02] I will talk about is like how we are
[18:04] helping
[18:05] um developers to actually make sure that
[18:09] the overall velocity of the entire
[18:10] pipeline is maintained as more and more
[18:13] code is getting written. Now before I
[18:15] jump into that one of the fact is that
[18:20] we're talking about developer
[18:21] productivity but the amount of time
[18:24] developers spend writing and authoring
[18:26] code is anywhere between 16 and 25%.
[18:30] Different research studies have shown
[18:32] different amounts of time developers
[18:34] will spend writing code. So while it is
[18:37] important to improve that productivity,
[18:39] it is equally important to focus on the
[18:41] rest of the SDLC which will include
[18:44] testing, documentation, pushing it into
[18:47] production, operating it,
[18:48] troubleshooting problems and then
[18:50] optimizing it overall the entire cycle
[18:53] of authoring and and developing code. So
[18:56] that's what I will focus on. So if you
[18:59] look at this particular slide, uh there
[19:01] will be a pop quiz at the end to find
[19:04] out what all agents we actually have.
[19:06] Don't worry about the details of every
[19:08] slide. The point of the slide basically
[19:10] is that in addition to providing agents
[19:13] that help you author code, we're also
[19:16] providing agents that help you test
[19:18] code. Aloc briefly touched upon it.
[19:21] We're also providing agents that help
[19:23] you with code reviews. Right? Once
[19:24] you've checked in your code, you want
[19:27] code review agents to automatically kick
[19:29] in and do some testing. And we're not
[19:33] saying that all of this is so automated
[19:35] that the developer is completely removed
[19:37] from the pipeline. Even at Google, when
[19:40] the code is authored by AI, there is
[19:42] still a lot of developer checking and
[19:45] and uh code reviews done by humans to
[19:48] make sure that things are moving on the
[19:50] right track. But we are building and
[19:52] providing agents for testing, for
[19:54] documentation,
[19:56] uh for pushing these things into
[19:57] production, for troubleshooting problems
[20:00] and optimizing the cost of what you're
[20:04] deploying into these environments. So
[20:06] that's what I will focus on for the rest
[20:08] of the four or five slides that I have.
[20:10] So let's jump into the first agent, the
[20:13] design agent.
[20:15] Now as developers build their code and
[20:18] they want to certainly first test
[20:21] something on their local environment and
[20:23] that's fine but before it gets into the
[20:26] pipeline to go into production you want
[20:29] to test it in the cloud right which
[20:31] actually invokes other services it
[20:34] invokes data access and things like that
[20:37] but how do you get access to an
[20:39] environment
[20:40] which is in the cloud well many of times
[20:43] people will file a ticket you know
[20:44] somebody will provision some resources
[20:46] for you or if you have platform
[20:48] engineering teams you know they may have
[20:49] already built you know some environments
[20:51] for you where you can go and test. Now
[20:53] with the design agent we help automate a
[20:56] lot of that. So with the design agent a
[21:00] platform engineer can start off with a
[21:03] template that either we provide out of
[21:05] the box or you create on your own and
[21:09] the platform engineer or the developer
[21:11] interacts with the design agent. Again,
[21:13] as you can imagine, using natural
[21:15] language, while what this UI is showing,
[21:19] you do have a graphical canvas to see
[21:21] what your design looks like. But the
[21:24] authoring of the template, the
[21:26] modification of the template, the
[21:28] codification of your policies into the
[21:31] template can all be done using natural
[21:32] language. And through these policies,
[21:35] you can specify things like what
[21:38] configurations can the person who's
[21:40] instantiating the template make changes
[21:42] to. You can specify security policies.
[21:45] You can specify scaling policies like
[21:47] how much do I allow somebody to scale
[21:50] this environment. So you can specify a
[21:51] lot of policies and once you have these
[21:54] templates created, you know, you can
[21:56] make it ready for the developers to use
[21:58] these template, instantiate them and do
[22:01] their testing. Now when the template is
[22:05] instantiated, we do pre-flight checks
[22:08] and these pre-flight checks will make
[22:09] sure that any of the policies that
[22:11] you've specified as a part of the
[22:13] template are actually invoked before the
[22:16] template uh is instantiated.
[22:19] Now we provide many out-of-the-box
[22:21] templates for building a web
[22:23] application, for building an application
[22:25] that will access data, etc., etc. And
[22:27] these templates are based on best
[22:30] practices that we have built internally
[22:33] or you know working with our customers.
[22:36] Now what we're also working on is an out
[22:39] of the box template for agent platform.
[22:44] So yesterday if those of you who
[22:46] attended Thomas' keynote he talked a lot
[22:48] about the Gemini enterprise agent
[22:50] platform. As you build agents and deploy
[22:54] them to the Gemini enterprise agent
[22:56] platform, which sounds like a mouthful
[22:58] right now, um you may need services like
[23:02] an agent registry where you will publish
[23:04] your agents. You may need agent gateways
[23:08] that will be monitoring the traffic and
[23:09] enforcing policies. You may need model
[23:12] armor to check prompts. You may need,
[23:15] you know, an agent identity system that
[23:17] will give credentials to these agents to
[23:20] operate. Now obviously expecting anybody
[23:22] in your company whether it's a developer
[23:24] or even a builder right people who are
[23:26] using these tools to build new
[23:28] applications to go and provision all of
[23:30] these services is expecting a lot. So by
[23:33] providing an out-of-the-box template for
[23:35] the agent platform you know literally
[23:37] somebody can go and instantiate all of
[23:39] these services and start using those.
[23:42] Now a lot of conversation we always have
[23:45] is about green field green field
[23:47] environments where you're building
[23:49] something brand new but as you all know
[23:52] in the enterprise there are a few green
[23:54] field environments 90% of your
[23:56] environments are probably brownfield
[23:57] environments and you may have already
[23:59] built terraform um to work with your
[24:04] existing systems. What we are also
[24:06] announcing this week here is that if you
[24:08] have this terraform that can actually be
[24:10] imported and the design agent and the
[24:12] application design center which is a
[24:14] canvas on top of it will understand
[24:16] those and incorporate them
[24:19] into the templates and designs that you
[24:21] create using this agent.
[24:24] The second agent is what we call the
[24:26] investigate agents. Now again this is a
[24:30] rhetorical question but I won't be
[24:31] surprised with the answer. How many of
[24:33] you build systems that never have any
[24:35] problems and you have no have you never
[24:36] have to troubleshoot anything?
[24:39] Okay, there's one person two. Awesome. I
[24:42] would like to talk to you guys after the
[24:44] session. That would be an interesting
[24:45] conversation. But as you deploy
[24:48] applications or agents, they will
[24:50] invariably have issues and problems. A
[24:53] lot of that troubleshooting is very
[24:55] manual, very tedious. Welcome to the war
[24:57] room kind of situation. Now the
[24:59] investigate agents help you again use
[25:02] natural language to diagnose these
[25:05] problems. How do they actually work? So
[25:08] they use the Gemini reasoning models and
[25:12] they will analyze and evaluate your
[25:15] telemetry signals, logs, metrics, traces
[25:19] to be able to come up with observations
[25:22] and hypothesis on what could potentially
[25:24] be going wrong. Those were the signals
[25:28] that we used to analyze and still
[25:29] analyze. But we have also now enriched
[25:32] them with additional signals which
[25:34] includes the application topology.
[25:37] So if you have built an application that
[25:39] you've deployed to GCP and you have
[25:42] populated the underlying platform
[25:43] component called apphub which is where
[25:46] the application model is stored that
[25:49] information will be included as the
[25:51] agent analyzes the other signals. What
[25:54] will also be included are things like
[25:56] metric anomalies
[25:58] and what you can include and that's
[26:01] something you have to actively do is
[26:04] runbooks that you may have in your
[26:06] environment because those are the things
[26:08] you sometimes use to troubleshoot
[26:10] problems. So if you have runbooks that
[26:12] may be stored in Confluence or Jira, you
[26:14] can you bring that information and
[26:17] specify that to the investigate agent so
[26:19] that it can use all of that information
[26:21] collectively and go analyze all of these
[26:24] signals. And it comes up with two
[26:26] things. There's observations.
[26:28] Observations, not technically anomalies,
[26:31] but observations are things that may be
[26:33] interesting. And these interesting
[26:35] things actually make the foundation for
[26:38] the hypothesis.
[26:40] And these are probabilistic systems. So
[26:42] hypothesis basically are you know some
[26:46] probability of this may have gone wrong.
[26:49] And based on those hypothesis
[26:51] then you can explore further
[26:54] interactively to say what could
[26:56] potentially be the root cause. Now one
[26:58] of the new things that we have announced
[26:59] again this week is moving these
[27:03] investigations from a reactive mode to a
[27:06] more proactive mode.
[27:08] So
[27:10] last week if you went and used these
[27:12] capabilities, you had to actively launch
[27:15] an investigation. You could go to a log
[27:18] event that you identified. You could go
[27:19] to an alert that may be interesting and
[27:22] launch an investigation.
[27:24] But we recently are now we are
[27:26] introducing proactive investigations. So
[27:29] as you define your alerts in your
[27:31] systems and if when an alert is fired an
[27:34] investigation can be launched
[27:35] automatically. So by the time a user is
[27:38] notified, they get the war room
[27:40] together, the analysis has already been
[27:43] done and the hypothesis is shared with
[27:45] you in your console.
[27:49] Last but not least until last week when
[27:53] the hypothesis was supplied and if next
[27:57] to each hypothesis there was a suggested
[28:00] remediation which meant that if this
[28:02] hypothesis is the root cause this is how
[28:05] you can go and remediate the problem
[28:08] that's those were suggestions like we
[28:10] did not actually execute those
[28:12] suggestions and those suggestions were
[28:14] also in terms of G-Cloud commands but
[28:17] they were template adverised meaning you
[28:18] still had to fill in the information
[28:20] what's your project ID what's the
[28:22] resource ID etc now that has evolved to
[28:26] bring that context in automatically and
[28:29] literally with one click we still have
[28:31] the human in the loop right we're not
[28:33] automatically executing these
[28:34] remediations the human can still review
[28:38] the hypothesis the suggested remediation
[28:41] but with one click you can actually go
[28:42] ahead and execute the remediation and
[28:44] it'll a it'll make the changes to your
[28:46] environment
[28:49] The third agent I want to talk about
[28:51] briefly is the optimize agent. This time
[28:55] I will not ask a rhetorical question
[28:56] because I know what the answer is going
[28:58] to be. Now you all probably are
[29:01] surprised from time to time about cost
[29:04] spikes, right? It could be because you
[29:08] know somebody's running some rogue
[29:09] application. Maybe the workload has gone
[29:11] up which is a good thing for your
[29:12] business or maybe you know somebody's
[29:15] deployed agents and the agents are doing
[29:17] a lot of reasoning and chewing up a lot
[29:18] of tokens.
[29:20] These cost anomalies can obviously be
[29:23] challenging for the business. And the
[29:25] other ch related challenge is when your
[29:28] fin teams look at their cost dashboards
[29:31] and come ask the devops or the IT ops
[29:34] teams about hey we're seeing a cost
[29:36] spike what could be going on. Most of
[29:39] the time the response from it is well
[29:41] here's our metric dashboard you figure
[29:44] out why the cost is going up. So there
[29:46] is a clear gap between the conversation
[29:48] the two teams are having. The optimize
[29:51] agent will literally act as your
[29:53] personal assistant to analyze cost
[29:55] information.
[29:57] You can ask it questions but why is my
[30:00] cost going up? Which resource is
[30:01] utilizing a lot more uh is is highly
[30:04] heavily utilized and you will get
[30:06] appropriate answers from that analysis.
[30:09] It will also do cost to change
[30:12] correlation. So if your environment has
[30:14] changed, if you have changed a
[30:15] configuration, if you deployed a new
[30:17] application, that information is fed
[30:19] into the cost analysis and the cost
[30:21] analyzer can actually tell you these are
[30:24] most likely the changes that have caused
[30:26] costs to to spike. Pardon me. And like I
[30:30] said on the previous slide, this is also
[30:34] this can also be activated proactively.
[30:36] So you can define costbased alerts and
[30:40] the system will continuously be
[30:42] analyzing the cost information, identify
[30:44] anomalies and once it has identified
[30:47] anomalies, do the correlation to the
[30:49] resource usage and be able to tell you
[30:51] what could potentially be causing the
[30:53] cost spike.
[30:54] All right, so like I said, we've
[30:58] introduced these three agents. There are
[31:00] other agents for testing and
[31:01] documentation, etc.
[31:03] Let me just briefly touch upon why we
[31:06] are doing this and what's in it for you.
[31:08] So the first thing is it's the focus on
[31:10] the complete SDLC. Like I said, it's not
[31:13] just about coding. Coding is critical.
[31:16] Without code, you have, you know,
[31:17] nothing to worry about. But once you
[31:20] have written the code, once you've
[31:21] accelerated the speed and productivity
[31:23] of building code, you have to make sure
[31:26] that this code makes it to production
[31:28] and it continues to stay up and running.
[31:31] And so we have introduced agents for the
[31:33] entire SDLC,
[31:35] inner loop, outer loop, the whole thing.
[31:38] The second part is the full stack
[31:40] integration.
[31:42] And again, if you attended the keynote
[31:44] yesterday, Thomas talked about the AI
[31:46] stack. And when the AI stack, what he
[31:49] was talking about was from the
[31:52] hypercomputer to the models to the
[31:54] agents. That is certainly true. But we
[31:57] also have all of these agents, whether
[31:59] they're the coding agents or their
[32:01] operational agents, they are part of the
[32:03] GCP platform, right? They work with the
[32:06] same identity systems. They work with
[32:08] the same registries. They work with the
[32:11] same gateways. And as a result, whether
[32:14] you're a developer or an operator, you
[32:16] get a pretty comprehensive experience
[32:18] with the same underlying services that
[32:21] actually support building and deploying
[32:23] these agents. And last but not least,
[32:26] the value of these things. These things
[32:28] are packaged and priced into a single
[32:30] skew that you purchase and it has
[32:33] predictable pricing
[32:36] and you have very high practically no
[32:38] limits today for usage and the design
[32:42] agents that all these um other agents
[32:44] they're using tokens um but you're
[32:47] purchasing them in a skew that is
[32:49] subscription based.
[32:50] So with that I would like to invite
[32:53] Sachin on board to talk about how they
[32:56] have used all of these capabilities at
[32:58] whipro to automate and improve their
[33:01] environments.
[33:13] Good morning everyone. Am I audible?
[33:17] Yeah. So I'm Sachin Sachin Chandra uh
[33:20] the global practice head for Google
[33:22] cloud in VRO technologies.
[33:26] Thanks to Dagesh and Aloc. I can proudly
[33:30] tell that like we are a customer for
[33:33] Geminina cord assist and most of the use
[33:36] cases what Dash and Aloc explained here
[33:40] we have seen them in action.
[33:44] Okay. But I want to talk about one
[33:47] specific challenge what we have faced
[33:50] while we started adopting GCA in VRO and
[33:55] how we have handled it. When we have
[33:58] taken Gemini assistant licenses for our
[34:02] developer community within VRO
[34:05] the adoption we have seen that it's very
[34:08] flat in initial few months. It was not
[34:11] even touching 100.
[34:13] Then we did an analysis and we could
[34:16] find that where is the mind block right
[34:19] because VRO already had many other
[34:23] platform available
[34:26] for usage and you all know any new
[34:29] platform comes to market or to for you
[34:32] to consume the question is that why a
[34:35] new tool what is that I'm going to get
[34:37] why should I put effort in learning a
[34:39] new tool and taking effort to integrate
[34:42] that
[34:44] and definitely there is a lot of
[34:46] onboarding challenges, adoption, mind
[34:49] share. So that is where we have taken a
[34:52] structured approach to handle this and
[34:55] that approach is around mindset, skill
[34:59] set and tool set. The mindset is about
[35:03] how do we
[35:06] build the mind share with the developer
[35:09] community. For that what is the the
[35:11] first to identify who will benefit the
[35:15] most by using Gemini cord assist. In VRO
[35:19] we have picked up a set of audience or
[35:21] developer community working with
[35:24] customers on Google cloud technologies
[35:26] or Google cloud
[35:29] migration. We have picked up them as a
[35:32] pilot group.
[35:36] The second part was about how do we
[35:38] build that mind share. So we conducted
[35:41] multiple ideathon hackathon with the
[35:44] help of Google and it was a very
[35:46] interactive session. It was not a
[35:48] classroom sessions. We co- built
[35:53] solutions in the room itself. Right? We
[35:56] have built around 150 plus agents and to
[35:59] our surprise some of the developers came
[36:01] out with great ideas and built a lot of
[36:04] new themes in the sessions. We conducted
[36:07] around 40 plus in uh inerson enablement
[36:11] session across the globe and multiple
[36:16] ideathon and hackathon.
[36:19] So in the skill set so this is about the
[36:21] mindset skill set we also onboarded a
[36:25] very specific
[36:27] uh geminate cord assist related best
[36:29] practices SOPs we created a community
[36:33] and uh the people who had really seen
[36:36] the benefit they had been giving the
[36:38] examples of where it has worked well
[36:43] now I'll come to the tool set this is
[36:45] very interesting right while we have
[36:48] seen
[36:49] and used it for the standard software
[36:52] development life cycle
[36:54] and we have seen most of the metrics
[36:58] aligned to the industry standards. We
[37:00] use this for uh platform development. We
[37:03] use this for uh some of the key customer
[37:06] development for SDLC.
[37:09] We have used for some of the SAP
[37:11] modernization use case we have seen that
[37:14] is working very well
[37:16] but we did not want to limit GCA to just
[37:21] to the core productivity we want to take
[37:24] this to and play to the strength of
[37:27] Geminina
[37:29] and it is for us adoption of GCA is not
[37:34] just the productivity improvement but
[37:36] reimagination of developer experience.
[37:39] experience and to that we wanted to play
[37:42] to the strength of GCA and one thing
[37:45] what we have seen is that GCA works very
[37:48] well in CLI very well with Geminina in
[37:55] services within Google cloud like Gemini
[37:57] in BigQuery Gemini cloud assist kind of
[38:00] technologies we have really seen the
[38:03] power of GCA
[38:05] and I'll take you to some are the use
[38:09] cases where we have really used this. We
[38:12] have used this extensively really for
[38:14] cloud operations. Take an example like
[38:17] an S sur like your GK clusters are
[38:22] breaking because of some arbback uh
[38:25] security issues or access issue. In a
[38:29] typical way, it takes hours for us to
[38:32] really understand the root cause and
[38:35] come out with the remediation. By using
[38:38] Gemini cloud assist and CLI, we could
[38:41] actually bring that effort to minutes
[38:44] and any kind of a security incident. Say
[38:47] for example you have seen some kind of a
[38:49] cyber threat somebody is trying to some
[38:52] suspicious activity in your environment
[38:54] that entire root cause analysis and
[38:56] investigation by using CLI and a
[38:59] combination of Gemini crowd assist we
[39:01] have seen it very working very well. So
[39:05] by taking the power of CLI Gemini in the
[39:10] uh Google services we could actually
[39:14] take the assisted
[39:17] productivity
[39:18] to an agentic workflow that is the
[39:22] transformation we have seen and I'll
[39:24] show you the outcome right the outcome
[39:26] talks all and you can see that first few
[39:29] months the adoption was very flat and it
[39:32] really gone multi defaulted in few weeks
[39:37] to months. And so to summarize, it is
[39:40] about identification of the right set of
[39:42] people who will get the maximum benefit
[39:44] of GCA.
[39:47] Identifying the right use cases. Yes,
[39:49] every the standard productivity is
[39:51] there. It has been there with multiple
[39:53] products. But there are certain unique
[39:56] power of GCA playing to that and with
[40:01] the
[40:02] continuous learning and evolving that
[40:05] with the help of Google had really
[40:06] helped in maximizing the adoption for
[40:09] us.