From scripts to agents: OpenAI’s new tools unlock the next phase of automation

Automation has shaped PPC for decades, and the landscape keeps shifting.

I’ve seen that evolution firsthand, from helping build the first AdWords Editor to developing early Google Ads scripts and writing about automation layering.

Now we’re entering another major transition. 

As AI changes how we search and get answers, it’s also transforming how automation itself gets built. 

And this time, the momentum isn’t coming from ad platforms like Google – it’s coming from AI companies like OpenAI.

Until recently, AI mostly helped with human language tasks like writing ad copy, summaries, or reports. 

But the latest generation of LLMs can increasingly generate computer language too, including the software and workflows that streamline how we work. 

At OpenAI’s DevDay in San Francisco, the company introduced AgentKit, a new way to build AI that can take action.

It marks the start of a phase where the automation mindset that powered PPC optimization can extend far beyond campaigns and into entire workflows.

Imagine if AI could handle your everyday busywork

Picture this:

• A client sends a CSV with weekly results, and before you’ve even opened the email, the file is saved to the right folder and added to your dashboard.
• A client asks for a meeting – AI checks your calendar, drafts an agenda, and schedules it.
• You start writing new ad copy with AI, and the system automatically pulls your brand guidelines and checks for tone and compliance.

This is all possible today, and you don’t need an engineering degree to make it happen. 

If you can define how your work is broken down into distinct tasks, you can create an agent that does those steps for you.

Dig deeper: 4 ways to connect your ads data to generative AI for smarter PPC

What agents really are

An AI agent is a smart helper that can figure out what needs to happen and then take action using connected tools.

Software has historically been built around deterministic steps. If X, do Y, else do Z. It’s predictable, but inflexible. 

And it requires humans to define every possible scenario that should be covered, which makes writing a helpful program time-consuming and difficult.

But just like an LLM is flexible in how it answers your questions, it can use that flexibility to automatically figure out a reasonable next step to complete a task. 

Instead of replying with text, agents can reason through steps, call APIs, and perform tasks.

I’ve explained early versions of this before: 

• You ask ChatGPT for restaurant ideas while planning a trip.
• It suggests a few places.
• It then uses an app like Resy to book the reservation.

That’s what an agent does: it can understand your intent and take a real-world step.

This concept builds on earlier OpenAI features, such as GPT Actions and function calling, which gave models controlled access to outside data. 

Agents are the next evolution – they combine reasoning with execution, meaning they can plan and act in the same flow.

Now, think about that in PPC terms. 

An agent could pull campaign data, summarize results, and even reference brand or policy docs before generating compliant creative. 

That’s a big step up from traditional “AI writing assistants.”

Dig deeper: AI agents in PPC: What to know and build today

From coding projects to five-minute builds

AI agents aren’t a new idea. 

Many marketers, myself included, have experimented with them for more than a year, but it used to take a lot of technical work. 

About a year and a half ago, I built an agent based on the two books I’d written that could answer questions in my tone and reference my ideas. 

I used LangChain, one of the first frameworks for connecting large language models to data and tools. It worked, but it wasn’t quick. 

I had to learn vector databases, RAG, and several other moving parts to get it working – not something most PPC pros want to tackle on a Monday morning.

Since then, several companies have made it easier to build agents like these, and some even feature them with a digital clone of a person, such as HeyGen. 

But when OpenAI introduces a way to create agents, I pay attention – and that’s what they did with AgentKit. 

It brings a visual interface for building agents directly on the platform of the most used chatbot.

What used to take hours or days of development can now be done in minutes, and you don’t need to know how to code.

AgentKit: ‘Zapier for AI’

AgentKit is OpenAI’s new toolkit for creating agents that can connect to tools and take actions through those tools. 

It’s a visual builder where you link services like Gmail, Dropbox, or Slack, and describe what the agent should do using tools you already use every day.

If you’ve ever used Zapier, n8n, Make, or Rule Engine, the concept will feel familiar: you connect blocks in sequences that represent what you want to happen. 

But because a flexible AI model sits at the core of these flows, AgentKit is different – it can use reasoning instead of rigid rules. 

If that sounds scary, you can add a simple human-in-the-loop approval step to any flow.

Instead of “If X happens, do Y,” you can say, “If a client sends a campaign report, summarize it and save it to the right folder.” 

The AI figures out how to do that by making reasonable requests that help it understand what you mean by vague instructions like “the right folder.”

For PPC marketers, this opens the door to automating work around campaigns (think reporting, documentation, and creative preparation), without waiting for a platform feature or a developer.

---

The unsung hero: Model Context Protocol (MCP)

Under the hood, much of the power that enables agents to take action comes from the Model Context Protocol, or MCP. 

It’s not brand-new, but it’s the key piece that makes all of this work.

MCPs are the connectors that let agents talk to your tools or data in a structured way. 

If you think of APIs as the connectors of the web, MCPs are similar, but built as a standard that any LLM can use. 

Some are built by OpenAI, like the connectors for Dropbox or Gmail. 

Others come from third-party developers, like Box. 

And you can create your own to connect private data or internal systems.

You can think of it this way: MCPs are the plumbing. AgentKit is the faucet.

The plumbing defines what data can flow where. The faucet is how you turn that into something usable.

Without MCPs, an agent would be like a brilliant intern with no logins to any of the systems they need. 

With them, the agent can safely use your data and tools with clear permissions.

Dig deeper: How Model Context Protocol is shaping the future of AI and search marketing

MCPs in plain terms

If this still sounds abstract, think of an MCP as a menu of what an AI can do inside a given flow.

For example, the Google Ads MCP currently includes actions like:

• Search for entities.
• List connected customers.

That’s it for now. It can read data, but it can’t change bids or create ads yet. 

That limitation is a good illustration that MCPs don’t open the door to entire systems for an LLM to go wild. 

Instead, they provide a defined set of capabilities created by the MCP developer. 

It’s an important guardrail. And even with MCPs that offer broader capabilities, you still control exactly which actions your agent can access when you integrate them into a flow.

Even in this early state, it’s a clear preview of how AI might eventually interact with Google Ads data through well-defined, secure interfaces.

Example: A ‘brand-safe ad assistant’

Here’s what this looks like in practice. 

Imagine you want an AI assistant that writes Google Ads while automatically following your brand voice and legal disclaimers. 

In AgentKit, you could create an agent with two connected tools: 

• Dropbox, where your brand guidelines live.
• A vector store with your agency’s tone and policy docs.

You could then ask the agent to “write new RSA headlines for our fall campaign using our style and disclaimers,” and it would connect with the right data to complete the task. 

Behind the scenes, it reads the files, extracts the rules, and generates compliant ad copy. You still approve the final version, but the prep work is automated.

It may sound simple, especially since you can already do this with a custom GPT, but it shows how these building blocks can be expanded. 

For example, you could integrate an MCP for your email platform and have the agent send a client an approval request for the creatives it generated.

Connecting data sources in AgentKit

Here are the steps to create an agent connected to the two data sources mentioned above. 

In Agent Builder, click the + icon next to Tools to give your agent a new capability, such as connecting it to an MCP.

Choose an existing MCP, like the ones shown here, or connect a custom MCP by clicking + Server.

You can also add a file search capability and select the files to include directly in the pop-up dialog.

Now you can interact with the agent to see how it uses its new abilities to produce better answers and, where enabled, how it uses other tools to take actions.

Dig deeper: How to get smarter with AI in PPC

Why this shift matters for PPC

If you’ve been in PPC for a while, you’ve seen this script before. 

We went from manual optimizations, to automated rules, to scripts, to automation layering – and each wave changed the skill set needed to stay ahead. Agents are the next wave.

Instead of writing scripts or building workflows with APIs, we’ll soon describe them in plain English and let AI generate the logic. 

That amplifies what marketers can do. 

The core skills stay the same – strategy, measurement, and judgment – but the way we build automation is about to get much faster, more flexible, and far more accessible.

What these early agent tools reveal about what’s coming

The current tools for building AI agents are still early. 

Setting up an MCP takes some configuration, and the Google Ads connector is limited to reading data. 

But the potential is clear: AI will move beyond generating text to running workflows, checking rules, and getting work done.

If you want to stay ahead of this shift, start small. 

Experiment with simple automations that connect your email, files, or reports. 

Learn what agents can and can’t do yet. 

Just as marketers who adopted scripts early will be the ones setting the standard later, those who learn this now will be the ones setting the standard later.

Dig deeper: Agentic PPC: What performance marketing could look like in 2030