Product images: Anthropic, OpenAI, Google ADK and Gemini Gems official pages
I have worked in IT for about twenty years, and the first thing I tell people who ask how to build an AI agent is that the phrase covers two very different jobs. One is filling in a form in a no-code studio so a bot answers questions from your documents. The other is writing a program in which a model calls tools in a loop. This guide follows the searches people run next on Google (with ChatGPT, with Claude, with Python, for free, with Copilot, with Gemini, from scratch) and shows what each route needs, using the vendors' own documentation, all checked on October 28, 2026.
Quick answer- No code, work setting: Microsoft Copilot Studio. Its quickstart has you describe the agent in your own words, add a knowledge source, test it and publish to a demo website.
- No code, personal use: Gemini Gems. You name the Gem, write instructions and can add files, but Google says Gems move to skills from November 2026.
- Python: the OpenAI Agents SDK and Google's Agent Development Kit both start with an agent defined in a few lines plus a function the model can call.
- Claude: the Claude Agent SDK is a Python and TypeScript library, and Anthropic's agent guide says to start with the simplest design that works.
Jump to: From scratch | With ChatGPT | With Claude | With Python | For free | With Copilot | With Gemini | Reddit and forums | Is it hard | Compare | First agent steps | Final pick | FAQ
This is general information. Pricing and limits change, so check each vendor's page before you commit.
How to Build an AI Agent From Scratch: What an Agent Actually Is
Image: Anthropic (official page)
Anthropic's guide, Building effective agents, separates two things people call agents. Workflows are systems where models and tools are orchestrated through predefined code paths. Agents are systems where the model dynamically directs its own process and tool use. Anthropic groups both under "agentic systems", and that distinction is the most useful starting point for a beginner.
The guide describes the basic building block as a model with three additions: retrieval, tools and memory. It calls this the augmented LLM. Everything else, from a support bot to a coding assistant, is that block wired together in different ways.
Image: Anthropic (official page)
The article is dated December 19, 2024, and carries a note that much of the tooling it describes has changed since then and points readers to Anthropic's newer Managed Agents material. The design advice still reads as sound to me, but treat the product names in it as dated.
My take (20 years in IT): Write the job down before you pick a tool. One sentence for what the agent does, one for what it must never do, and one for who checks its work. If you cannot write those three sentences, no platform will fill the gap for you.
Start with a workflow, not an agent
Anthropic recommends finding the simplest solution possible and adding complexity only when it demonstrably helps, and says this may mean not building an agentic system at all. It names five workflow patterns: prompt chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer.
Image: Anthropic (official page)
Prompt chaining splits a task into fixed steps, where each model call handles the output of the previous one. Routing sorts an input and sends it to a specialised follow-up, for example separating refund requests from technical questions. Use these when the steps are known in advance.
Image: Anthropic (official page)
When a real agent makes sense
Anthropic says agents suit open-ended problems where the number of steps cannot be predicted and a fixed path cannot be hardcoded. It also warns that autonomy means higher costs and the potential for compounding errors, and recommends extensive testing in sandboxed environments with guardrails. At each step the agent should get "ground truth" from the environment, such as tool results, and a stopping condition such as a maximum number of iterations keeps control with you.
Image: Anthropic (official page)
How to Build an AI Agent With ChatGPT: What Is Possible
Can you build an agent with ChatGPT? The documentation I could read answers it by pointing at code. The OpenAI Agents SDK quickstart has you create a project and virtual environment, install the SDK with pip install openai-agents and set an OpenAI API key. An agent is then defined with a name, instructions and optional settings such as a model.
Image: OpenAI (official page)
The quickstart then walks through four steps. You run the agent with a runner and read its final output, give it tools, add a few more agents and define handoffs between them. A handoff means a specialist takes over part of the conversation, while "agents as tools" keeps one orchestrator in control. The page says to decide who should own the final answer before choosing between them.
Image: OpenAI (official page)
Image: OpenAI (official page)
from agents import Agent, Runner
agent = Agent(
name="History Tutor",
instructions="You answer history questions clearly and concisely.",
)
result = await Runner.run(agent, "When did the Roman Empire fall?")
print(result.final_output)That snippet is adapted from the quickstart's own example, trimmed to the core. It runs inside an async function in the full version, so use the vendor page rather than copying this fragment.
Image: OpenAI (official page)
For a second turn the quickstart offers three ways to carry the conversation forward: pass the earlier result back in, attach a session so the SDK loads and saves history, or reuse OpenAI's server-managed state. I did not read OpenAI's help pages for building custom GPTs inside ChatGPT, so this guide does not describe that route.
How to Build an AI Agent With Claude: SDK and the Guide
Image: Anthropic (official page)
Anthropic's Agent SDK overview defines an agent as an application that completes a task by planning its own steps and calling tools that read files, run commands or edit code. The SDK gives you the same tools, agent loop and context management that power Claude Code, programmable in Python and TypeScript.
Image: Anthropic (official page)
The page compares four options by who runs the agent. The Agent SDK embeds Claude Code's agent in your own application, running in a process you operate, with built-in tools, permissions, sessions and hooks. The CLI is for interactive terminal work. The page also lists a Client SDK and Managed Agents, so read the comparison table before you choose.
Anthropic's guide adds a caution about frameworks. They simplify calling models, defining tools and chaining calls, but they can add layers of abstraction that obscure the underlying prompts and responses and make debugging harder. Its suggestion is to start with the model APIs directly, since many patterns take only a few lines of code, and to understand the code underneath if you do use a framework.
Image: Anthropic (official page)
How to Build an AI Agent With Python: Two Official Quickstarts
Both quickstarts use a virtual environment and an API key, so the setup looks alike. The difference is the vendor and the model behind it.
Image: Google (official page)
Google's Python quickstart for ADK says to create a virtual environment, then run adk create my_agent. The generated project holds an agent.py file with the main control code, a .env file for API keys or project IDs, and an __init__.py. The only required element is a root_agent definition, and tools are ordinary Python functions you pass in.
Image: Google (official page)
Image: Google (official page)
from google.adk.agents.llm_agent import Agent
def get_current_time(city: str) -> dict:
"""Returns the current time in a specified city."""
return {"status": "success", "city": city, "time": "10:30 AM"}
root_agent = Agent(
model='gemini-flash-latest',
name='root_agent',
description="Tells the current time in a specified city.",
instruction="You are a helpful assistant that tells the current time in cities.",
tools=[get_current_time],
)Google's example tool is a mock that returns a fixed time, which makes a good point about tools: the model only decides when to call the function, and your code decides what the function really does. The quickstart says the project uses the Gemini API, which needs an API key you can create in Google AI Studio, and that ADK supports many other models. You can run the agent with adk run in the terminal or adk web for a browser interface.
Image: Google (official page)
Create Your Own AI Agent for Free: What Is Actually Free
I could confirm only a few things about cost, so here is the honest list.
- Copilot Studio trial: Microsoft says you can sign up as an individual and the free trial starts when you finish. The trial lets you create agents and test them in the test chat panel, but you cannot publish. It can be extended by 30 days, and Microsoft says an agent keeps working for up to 90 days after the trial expires. A personal email address may be rejected, in which case Microsoft says to use a work or school account.
- Gemini Gems: Google's help page says you can create and use Gems with a personal Google Account if you are 13 or older and signed in to Gemini Apps. It does not state a price on that page.
- Code libraries: the OpenAI and Google quickstarts install a library, but each agent calls a hosted model through an API key. I did not read the API pricing pages, so I cannot tell you what a test run costs.
Image: Google (official page)
Before you choose free, check that the tool can do the one thing you need. A trial that cannot publish is fine for learning and no good for a customer-facing bot.
How to Build an AI Agent With Copilot: Copilot Studio
Microsoft describes Copilot Studio as a graphical, low-code studio for building and managing AI-powered agents and workflows, connecting them to your organization's data and systems and publishing them to the channels where your users already work. An agent follows the instructions you give it, draws on the knowledge sources you connect and uses tools to take action.
The quickstart shows the flow. You sign in, describe what the agent should do in up to 1,024 characters, and the AI generates a name, description and instructions plus suggested triggers, knowledge sources and tools. Microsoft's example adds its own documentation as a knowledge source, then tests changes in the test chat before publishing to a demo website. Its advice is the best I have seen for beginners: make a change, test it again and repeat.
Licensing is covered on a separate Microsoft page, which also links an estimator for Copilot Credits volume. If you plan to publish, read that page first, because the trial cannot do it. For a longer look at Microsoft's small-business offering see Microsoft Copilot for Small Business in 2026.
My take (20 years in IT): No-code does not mean no-risk. Whoever connects a knowledge source decides what the agent can say, so connect a small, reviewed set of documents first. Do not point a new agent at a shared drive full of old files.
How to Build an AI Agent With Gemini: Gems and ADK
Image: Google (official page)
Google's Gems help page gives seven steps. Open gemini.google.com, open the sidebar, click Gems, click New Gem, enter a name and instructions, optionally add files under Knowledge, then Save. You can also ask Gemini to rewrite your instructions, add a file from your device or Google Drive, or add a NotebookLM notebook.
There are two limits to know about. The page says Gems cannot be used with Gemini Live for now, and it says that starting in November 2026 Gems will go away on personal Google accounts and automatically transition to skills. So a Gem built today is a short-term tool. A Gem is also an instruction set with reference files, closer to a configured assistant than to the loop-with-tools agent in Anthropic's guide, so for real automation the ADK route above is the one that calls your own code.
Image: Google (official page)
How to Build an AI Agent on Reddit? How to Read Forum Advice
Google shows forum threads for this search, and they can be a quick way to see what broke for other people. Treat them as anecdotes. Check the date, because agent tools and model names change within months. Look for answers that name the model, the SDK version and the exact error, and then confirm the fix in the vendor's documentation before you rely on it.
Is It Hard to Build an AI Agent?
Image: Anthropic (official page)
Anthropic says agents can handle sophisticated tasks but that their implementation is often straightforward: they are typically just models using tools based on environmental feedback in a loop. The hard parts it names are designing the tools and their documentation clearly, and managing the costs and compounding errors that come with autonomy.
In practice a first working agent is an afternoon project, and a trustworthy one is not. The quickstarts above get you to a reply in minutes. The remaining work is deciding what the agent may touch, testing it on bad inputs and keeping a person in the loop. Anthropic's own advice is to pause for human feedback at checkpoints or when the agent hits a blocker.
Image: Anthropic (official page)
Quick Comparison of the Build Paths
| Path | Best for | What you need | Watch out for | Official page |
|---|
| Copilot Studio | Work agents without code | A Copilot Studio sign-up | Trial cannot publish | Visit site |
| Gemini Gems | Personal assistants | A personal Google account, age 13 or over | Gems become skills from November 2026 | Visit site |
| OpenAI Agents SDK | Python agents with handoffs | Python, a virtual environment, an OpenAI API key | API usage cost not checked | Visit site |
| Google ADK | Python agents with tools | Python, the ADK package, a Gemini API key | Mock tool in the example, replace it | Visit site |
| Claude Agent SDK | Agents that use files and commands | Python or TypeScript | Read the comparison with other Claude tools first | Visit site |
A Safe First Agent in Six Steps
This list is my own checklist, built on the guidance quoted above. It is an opinion, not a vendor procedure.
- Write the job, the limits and the person who reviews the output.
- Pick the simplest route that fits: a no-code studio for documents and questions, a short workflow for fixed steps, an agent loop only for open-ended work.
- Give it one read-only tool.
- Set a stopping condition, such as a maximum number of steps.
- Test on messy and hostile inputs in a sandbox, as Anthropic recommends.
- Add a human approval step before anything is sent, paid or deleted.
My take (20 years in IT): If your first idea is "an agent that runs my whole inbox", shrink it. Start with one folder, one task and a daily review. You will learn more from ten reviewed outputs than from a month of an unattended agent.
Final Recommendation
If you work in a Microsoft shop and want something your team can use without code, start with Copilot Studio and check the licensing page before you promise anyone a published bot. If you code, pick the SDK that matches the model you already have an account for, and read Anthropic's guide before you add multiple agents. If you only want a personal assistant with your own notes, a Gem will do for now, knowing it transitions to skills in November 2026. For where agents fit in a business, see AI Agents for Business Operations in 2026.
Frequently Asked Questions
Can you build an AI agent with ChatGPT?
The OpenAI documentation I read points to code: the Agents SDK quickstart installs a Python package, sets an OpenAI API key and defines an agent with a name and instructions. I did not read OpenAI's help pages on custom GPTs, so I cannot describe that route.
Is it hard to build an AI agent?
A simple one is not. Anthropic describes agents as typically just models using tools based on environmental feedback in a loop. The hard parts are clear tool design, cost, compounding errors and testing, which Anthropic says should be done extensively in sandboxed environments.
What is the difference between a workflow and an agent?
Anthropic says workflows orchestrate models and tools through predefined code paths, while agents direct their own process and tool use. Start with a workflow when the steps are known in advance.
How do I build an AI agent with Python?
Both the OpenAI Agents SDK and Google ADK quickstarts use a virtual environment and an API key. ADK generates a project with adk create my_agent, and the OpenAI quickstart installs the package with pip install openai-agents.
Can I create an AI agent for free?
Partly. The Copilot Studio trial lets you create and test agents but not publish them, and Google says personal Google accounts can create Gems. Code routes need a model API key, and I did not check API prices.
Are Gemini Gems going away?
Google's help page says that starting in November 2026 Gems will go away on personal Google accounts and automatically transition to skills. Check the page for the latest details.
Sources
- Anthropic, Building effective agents (December 19, 2024) (checked October 28, 2026)
- OpenAI, Agents SDK quickstart (checked October 28, 2026)
- Google, Agent Development Kit, Python quickstart (checked October 28, 2026)
- Anthropic, Agent SDK overview (checked October 28, 2026)
- Microsoft, Copilot Studio overview (checked October 28, 2026)
- Microsoft, Copilot Studio quickstart (checked October 28, 2026)
- Microsoft, Get access to Copilot Studio (checked October 28, 2026)
- Google, Use Gems in Gemini Apps (checked October 28, 2026)
Product images come from the vendors' official pages, are cropped and framed here, and belong to their owners. I did not build agents on every platform myself, and the claims about what each one does are the vendors' own.
Last updated: October 28, 2026.
Comments
Post a Comment