Hey, this is Lance from Lang. Gemini 3

just came out today. This was a highly

anticipated model release. And looking

at the results here, we can see it's

extremely strong across the board. And

there's this wide battery V valves

comparing Gemini 3 Pro, 225, Sonnet 45,

and GPD51

with the bold indicating

state-of-the-art performance. So, Gemini

is doing extremely well across the

board. But I do want to call your

attention to a few specific evals that

are particularly relevant for building

agents and that's these three right

here. Vending bench 2, Terminal Bench 2

and Sierra Tow Squared Bench. Now

vending bench 2 is for long horizon

planning tasks. Terminal bench 2 is for

terminal based largely coding tasks.

There's around 100 of them. So these are

tasks you can actually execute using a

command line in a terminal. Now ta

squaredbench is gentic task in the

context of real world like customer

support and so one of the things that

Gemini emphasizes in the release is that

it's very strong for building agents and

I want to test that and I'll test it

using our deep agent harness. So deep

agents is an open-source

agent harness we released and the nice

thing about it is there's a few built-in

tools that are very general and very

useful. notably a planning tool, a sub

aent delegation tool and simple file

system tools for reading writing files,

glob grip and using a shell. So these

are built-in tools to our agent harness

and you can of course provide your own

tools as well as instructions.

Now I recently created this quick starts

repo. It has quick start for deep

research because that's such a popular

task and I've added support for Gemini 3

to this repo. So let's have a look at

that. So here's a UI we can use to

interact with a locally running deep

agent deployment that is using Gemini 3.

And let's just look at this first and

I'll explain how it works in the repo

briefly. Go ahead and submit our

research request. So Gemini is going to

use the native tools provided to do

various things. We can look first. It's

going to call this to-dos tool to create

a few different tasks.

We can see the tasks listed here.

They're all pending. Here is the first

task to basically just write the

research request to a file. We can see

it kicks off this sub agent. Sub agent

does some research for us. We can see

it's all saved here. And we can see the

final research report is written to this

final report.md.

Nice

with some citations as well. Now what's

happening here is we're seeing Gemini 3

being able to successfully do a few

different things. Plan using this to-dos

tool that we give it. Write files. Kick

off sub aents. This is a sub agent that

it calls to actually kick off a research

task. It's able to then analyze those

results, update its to-dos, noting

completion,

write a final report, and give us kind

of a summary of its findings as well as

providing this final report. Now, these

files we're writing are actually just in

the Langraph state object, and so they

live in memory currently. But with DHS,

you can actually supply a backend that

would write to a fi to write to a file

system. So it's really testing the

ability of the agent to call various

file manipulation tools. Read file,

write file that we provide. And the back

end just happens to be the langraph

state object. Now if we zoom back to the

quick start repo, you can open up this

folder. That's where the readme for

everything we just did is shown. And

this actually covers how to get started

and what I did. I made sure that my

Google API key was set. That's all I

needed here. And I can run this in two

different ways in an interactive Python

notebook as well as a Langraph

deployment which is exactly what we just

saw. I kicked off a langraph deployment

simply running this command and I start

up this UI. You can see the instructions

here and that's what we were just

looking at this deep agents UI

interface.

Now open up the notebook I can show you

the prompts and the code in a little bit

more detail. So first this just the task

deep research for research. We supply

two different tools. Tableau search tool

and a think tool. You can find these in

the deep agent folder. Just open up this

subfolder and you can see this tools.py.

Those are your tools. Load them in. And

instructions. So these are just

instructions for the research task. You

can modify these any way you want. Of

course, these are some instructions that

I found to be useful with some heristics

that I like for steering agents. But of

course, these are just prompts. And I

visualize the prompts in notebook. You

can go through them on your own time if

you're interested. And custom sub agents

provide here.

Now, here's where specifically

we initialize Gemini 3. So again, it's

pretty simple. You're just going to

import from here. Lang chain Google

Genai right here. Set the model to

Gemini 3 Pro preview. There, set the

model. Now, this is just create a deep

agent. Again, this is using our deep

agents harness. I supply my model. I

supply any custom tools. For example,

for the research task here, I supply the

instructions we just talked about very

briefly above and I supply any custom

sub agents. Now, in the notebook, I can

interact with this agent in the same way

we did in the UI, but in this case,

we're directly using the deep agents

package, which we import. This is built

on top of Langraph. We can invoke it

like any other LN graph graph just like

this. Pass in our messages with the

research request. And you'll see the

messages here for display in the

notebook are actually quite similar to

what we saw in the UI. Here's the human

input. Here is the tool call to write

to-dos. Great. We write the research

request to a file. Great. And that's all

based on instructions.

So in the prompt, we tell the agent,

hey, write the request to file so you

can reference it later if you need.

Nice. We update the to-dos.

And we call our custom research sub

agent. That's great. We give it a topic

to research.

And this is the result of all that

research that happened within the sub

agent. So that's the beauty of using sub

aent to isolate context. It'll do a

bunch of work and just return the

results back to the parent agent. It

gives us a nice deep dive on contact

engineering with a bunch of sources.

That's great. We update to-dos again. We

write our final report based upon what

the agent provided.

Fantastic. Update our to-dos. We read

the research request.

Good. We mark all our to-dos as correct.

Verify that we satisfy the original

request. That's great. And we're done.

We can even fetch the file from the Lang

state object just like this. We can view

it. And here's our final report.

And all this is logged to Lenus. We can

open up the trace. Click here. And this

gives us an overview of everything that

happened in granular detail. And we can

see we are calling Gemini 3 Pro preview.

So great, we're using the Gemini 3. Now,

here's really the key point when working

in the notebook or using our local

deployment of our research agent with

Gemini 3. We can see that it can use

these various deep agent native tools.

We can see that it uses these native

tools, notably file manipulation tools,

planning, sub aent delegation very

effectively. This looks really good. The

reports generated look quite nice.

Token usage is moderate as expected for

research tasks, but it's not

unreasonable. And you can easily modify

this for your own use case. So Gemini 3

looks looks very promising. Of course,

the benchmarks are fantastic. It seems

to be a great model for building agents.

And we can see with our own deep agent

harness, it's able to utilize the

various tools really effectively for

task like research. I encourage you to

have a look at this. Feel free to play

with it using the deep agent harness.

And all this will be checked in. Again,

you can check see our deep agent quick

starts repo and see the deep research

readme for all the instructions about

how to run this yourself. So hopefully

this is a useful overview of both Gemini

3 and using it with our with deep agents

for a popular task like research.

Thanks.