Stage 4 of 6Intermediate·4–6 hours

Automating Real Work: Tools, Actions and Custom Assistants

A model that can only write is a consultant; a model that can act — search, calculate, send, update — is a colleague. Learn how tools work, how to build a custom assistant without code, and how developers wire actions in.

The idea

Everything so far has been text in, text out. Tools change that. A tool is a capability the model can ask to use — search the web, run code, read a calendar, create a ticket, send an email. The model does not run the tool itself; it says "call this tool with these arguments", the application runs it, and the result is handed back so the model can continue. That loop — ask, run, return, continue — is the core of every AI assistant that does things, and of every agent.

For non-developers this shows up as connectors and custom assistants. ChatGPT, Claude and Gemini can connect to Google Drive, Gmail, calendars, Slack, GitHub and hundreds of other services through connectors (many built on MCP, an open standard for plugging tools into AI). Custom GPTs, Claude Projects and Gemini Gems let you package instructions, files and allowed tools into a reusable assistant you can share with your team. No-code automation platforms (Zapier, Make, n8n, Microsoft Copilot Studio, Google AppSheet) add triggers: "when a form is submitted, have the model classify it and post to the right channel".

For developers this is function calling: you describe each tool with a name, a description and a parameter schema; the model decides when to call it and with what arguments; your code executes and returns the result. Good tool design — clear descriptions, few parameters, errors returned as data — matters more than the model. Everything after this point in the roadmap (agents, multi-agent, MCP) is this loop with more structure.

Vocabulary

Tool / function calling: The model requesting that the application run a named function with specific arguments.
Connector: A pre-built integration (Drive, Gmail, Slack…) an assistant can use on your behalf, with your permission.
MCP: Model Context Protocol — the open standard for exposing tools and data to any AI assistant.
Custom GPT / Project / Gem: A saved assistant with its own instructions, files and tools, shareable with others.
Human-in-the-loop: Requiring a person to approve an action (send, pay, delete) before the tool runs.

No-code walkthrough · non-developers

Build a shareable "Customer reply assistant" for your team, no code

For: Support, sales, admin, small-business owners, school offices

1Collect 10 real customer questions and the replies your best colleague wrote. These are your examples.
2Create a custom assistant: ChatGPT → Explore GPTs → Create; Claude → Projects → New project; Gemini → Gems → New Gem. Give it a name and paste the instructions below.
3Attach knowledge: your FAQ, pricing sheet, return policy, tone guide. Attach the 10 example pairs as a file.
4Enable the tools it should have — web browsing off if it should only use your documents; a connector to your shared Drive folder if policies live there.
5Test with 5 new questions, including one it should refuse ("can you give me a discount?"). Fix instructions, then share it with the team. Add a rule: "Never send — always produce a draft for a human to review."

Prompt to paste

You draft customer replies for [Company]. Use only the attached FAQ, policies and example replies. Tone: warm, brief, no jargon. Always: acknowledge, answer, next step. If the answer is not in the documents, draft a reply that says a colleague will follow up within one business day and flag the question with [NEEDS HUMAN]. Never promise refunds, discounts or dates that are not in the policy document. Output the draft only.

Check your work: The assistant should refuse or flag when the documents do not cover a question. If it confidently answers something not in the policies, tighten the instruction and add that case as a negative example.

Developer walkthrough · Gemini · Claude · OpenAI

One tool, the full loop: define it, let the model call it, execute, return the result, get the final answer. This is the same shape for every provider and the foundation of the Agent Workflows track. Note that errors are returned as data — a raised exception would end the turn.

Function calling end-to-end with one tool (order lookup). The loop is the thing to learn; the field names are trivia.

python

from anthropic import Anthropic

TOOLS = [{
    "name": "lookup_order",
    "description": "Look up an order's status by ID (format ORD-123456).",
    "input_schema": {"type": "object",
                     "properties": {"order_id": {"type": "string"}},
                     "required": ["order_id"]},
}]

def lookup_order(order_id: str) -> dict:
    order = DB.get(order_id)                       # your data layer
    if not order:
        return {"error": f"{order_id} not found. IDs look like ORD-123456."}
    return {"order_id": order_id, "status": order.status, "eta": order.eta}

client = Anthropic()
messages = [{"role": "user", "content": "Where is order ORD-482913?"}]
while True:                                         # the loop
    resp = client.messages.create(
        model="claude-sonnet-4-5", max_tokens=500, tools=TOOLS,
        system="You are a support assistant. Use tools; never guess order data.",
        messages=messages)
    messages.append({"role": "assistant", "content": resp.content})
    if resp.stop_reason != "tool_use":
        break
    results = []
    for block in resp.content:
        if block.type == "tool_use":
            out = lookup_order(**block.input)
            results.append({"type": "tool_result", "tool_use_id": block.id,
                            "content": str(out)})
    messages.append({"role": "user", "content": results})
print(next(b.text for b in resp.content if b.type == "text"))

1Ask about an order that does not exist. Confirm the model relays the error helpfully instead of inventing a status.
2Add a second tool (cancel_order) and a rule in the system prompt that cancellations require explicit user confirmation. Test that it asks first.
3Replace the in-process tools with an MCP server and connect it — the same server then works in Claude Code, Gemini CLI, and ChatGPT.

Practice

Everyone

Automate one recurring task end-to-end with a no-code platform: e.g. new form response → model classifies urgency and drafts a reply → post to a channel for a human to send. Measure minutes saved per week.

Developers

Build an assistant with three tools over a real system you own (a calendar, a to-do API, a database). Add an approval step for any tool with side effects. Log every tool call.

Pitfalls at this stage

•Giving an assistant send/delete/pay powers without an approval step. Draft-only first; automate sending once you trust it.
•Connecting everything. Each connector is data the model can see — connect the minimum the task needs.
•For developers: raising exceptions from tools. Return structured errors with a hint; the model can recover from data, not from a crash.