How to Create Your Own AI Agent: From One Job to a Tested Prototype

Quick Answer

To create an AI agent, define one job and what a finished result looks like, decide whether the job needs an agent at all, then build it with a no-code tool or a code library. Give it written instructions, the smallest set of knowledge and tools it needs, clear stopping points, and a test set that includes missing and out-of-scope requests.

The two example routes use Microsoft Copilot Studio and the OpenAI Agents SDK in Python, based on official documentation checked on October 16, 2026. Copilot Studio was not tested hands-on, and no current application screenshots were reviewed. The revised Python example passed local construction and lookup checks with SDK 0.24.0; no model call was run. The test table gives acceptance criteria, not observed model results.

The Example Job Used in This Guide

The sample job is a draft-reply assistant for a fictional project called Project Atlas. A team member asks a question, and the agent drafts a reply from a three-entry FAQ for the project lead to review before sending. The agent does not send anything, and it connects to no customer data, public channel, or tool that writes to another system.

Seven Steps to a Tested Prototype

The steps below apply to both routes. Each one shows what the Project Atlas example needs at that point; the final step defines the tests to run before calling it a tested prototype.

Step 1: Define the Job, the User, and the Finished Result

Write down who will use the agent, what they hand it, and what they get back. For Project Atlas, the user is the project lead, the input is one question, and the finished result is a short draft the lead can approve or edit.

A written finished result makes testing possible later. Here it reads: the draft answers from the FAQ, says plainly when the FAQ lacks an answer, and carries the "Draft for review" label.

Step 2: Decide How Much Complexity the Job Needs

Anthropic's engineering guidance recommends starting with the simplest solution and adding complexity when the job calls for it. It separates workflows, where steps follow a fixed code path, from agents, where the model directs its own steps and tool use. These categories are a design reference, and products use the terms in different ways.

The Project Atlas job could run as a single model call with the FAQ pasted into the prompt. It becomes a useful small agent example once the FAQ moves into a lookup tool, because the model then decides when to call that tool. If a single call already gives good drafts for a real job, keep the single call.

Step 3: Choose a Build Route and Check Its Requirements

Pick the route that matches the team's skills and accounts. The table lists what each route needs before work starts.

OpenAI also offers Agent Builder, a visual canvas. OpenAI announced its deprecation on June 3, 2026, and its documentation states that it is scheduled to shut down on November 30, 2026, so this guide does not use it.

Step 4: Write the Instructions

Instructions tell the agent what it may read, what to produce, how to handle missing information, and what it must not do. For Project Atlas, the instructions are:

Prepare text for review about Project Atlas using the supplied FAQ facts. For missing information, state what is missing and refer the question to the owner identified in the FAQ; decline questions about other projects. Explain that requests to send, edit, or delete content are outside this prototype, and do not claim to perform them. Label each response "Draft for review."

In Copilot Studio, the cited Learn quickstart uses the standard harness, with New experience turned off. It also notes that natural-language creation is unavailable in some environments. For an environment that supports that route, enter a description of up to 1,024 characters, such as "Prepare Project Atlas FAQ reply drafts for the project lead to review."

Copilot Studio then generates a name, description, and instructions, and suggests triggers, knowledge sources, and tools. Those suggestions can be accepted, ignored, or dismissed, and they do not persist beyond the session. After provisioning, edit the generated instructions to match the text above.

In the SDK, encode the same task requirements in the agent's instructions field, with the lookup topics added as shown in Step 5.

Step 5: Add the Smallest Set of Knowledge and Tools

Give the agent read access to what the job needs and nothing that writes elsewhere. Project Atlas needs read access to three FAQ entries. It needs no tool that sends, edits, or deletes anything.

For Copilot Studio, put the three fictional FAQ entries from the table into a local text file. Microsoft's file knowledge guide supports .txt files: open the agent, choose Add knowledge from Overview or Knowledge, upload the file, add its name and description, and select Add to agent. This source type requires Dataverse search in the environment; ask an administrator to enable it if it is unavailable. Review any additional knowledge or tool settings before testing, because instructions express intended behavior and do not replace access controls.

In the SDK, a function tool can hold the lookup. This example follows the pattern in OpenAI's Agents SDK quickstart:

import asyncio
import os

from agents import Agent, MaxTurnsExceeded, Runner, function_tool

# Fictional, non-public sample data for testing.
PROJECT_FAQ = {
    "kickoff": "Project Atlas kicks off on Monday, November 2, 2026.",
    "owner": "The project owner is the operations lead.",
    "tools": "The team tracks tasks in the shared project board.",
}


def read_faq(topic: str) -> str:
    return PROJECT_FAQ.get(topic.strip().lower(), "NO_ENTRY")


@function_tool
def lookup_faq(topic: str) -> str:
    """Read a Project Atlas FAQ entry.

    Args:
        topic: Use kickoff for the start date, owner for the project owner,
            or tools for the task location. Other topics return NO_ENTRY.
    """
    return read_faq(topic)


agent = Agent(
    name="Project FAQ drafter",
    model=os.environ["OPENAI_MODEL"],
    instructions=(
        "Prepare text for review about Project Atlas. Use lookup_faq to get facts. "
        "The topics are kickoff (start date), owner (project owner), and tools "
        "(task location). Other topics return NO_ENTRY. "
        "Answer from tool results without adding facts. For missing information, "
        "state what is missing, look up owner, and refer the question there. "
        "Decline questions about other projects. For requests to send, edit, "
        "or delete content, explain that you prepare drafts for review. "
        "Do not claim to perform those actions. "
        "Label each response 'Draft for review'."
    ),
    tools=[lookup_faq],
)


async def main() -> None:
    try:
        result = await Runner.run(
            agent,
            "When does Project Atlas start, and what is the budget?",
            max_turns=8,
        )
    except MaxTurnsExceeded:
        print("Stopped at the turn limit; review before retrying.")
        return
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

Save the code as project_faq_agent.py. In a Python virtual environment, install the checked package version with python -m pip install openai-agents==0.24.0. Set OPENAI_API_KEY locally, following the official API setup guidance, and set OPENAI_MODEL to the identifier of a tool-capable model your API project can access. Then run python project_faq_agent.py. Keep the key out of code, screenshots, and shared documents.

Local checks with SDK 0.24.0 confirmed that the revised script loads, the agent and tool construct, and the lookup returns the sample entries or NO_ENTRY. They did not execute Runner.run, authenticate to the API, or test the model's tool selection and answers. The expected output below remains a target to check.

Step 6: Set Stopping Points and Checkpoints

Decide where the agent stops and where a team member steps in. Anthropic's guidance describes agents pausing for human feedback at checkpoints and using stopping conditions such as a maximum number of iterations. For Project Atlas, the project lead reviews a draft before sending it outside this prototype. That review is a team procedure; the label does not implement an approval service.

The script sets max_turns=8 to bound model turns and stops with a review message if the SDK raises MaxTurnsExceeded at that limit. This is not a wall-clock or spending cap.

OpenAI's documentation distinguishes automatic guardrails from approval interruptions that let a person or policy approve or reject a sensitive action before the application resumes the saved run. Parallel guardrails may allow work to start while the check is still running. This sample implements neither guardrails nor an approval pause; it exposes a lookup that reads the sample data. If you add a tool with outside effects, configure its approval requirement and test how your application pauses, stores, and resumes the run.

Step 7: Test With Controlled Cases and Iterate

Run the agent on a small, fixed set of cases and compare each result with what the finished-result definition expects. Record the actual output next to the expected one.

In Copilot Studio, run these questions in the test chat panel, then adjust the instructions and run them again; the Learn quickstart describes the same test, change, and retest loop. In the SDK, replace the input passed to Runner.run for each case and inspect the answer; use traces, when available, to inspect tool calls. Passing these four cases shows the prototype handles them. It does not show that every branch, permission, or real-world question will behave the same way.

Bringing a Prototype Into Team Work

Once the prototype passes its test cases, the next questions are about the team: who owns the agent's work, where its drafts go for review, and who authorizes actions with outside effects. Syfo publishes this article and offers one way to organize that work. This section is optional, and it does not describe connecting an SDK or Copilot Studio agent to Syfo.

Syfo gives team members and named agents shared channels where agents post progress, sources, and deliverables in task threads. A task board shows which agent or team member owns each task, along with its status, linked deliverables, and next action. These records address ownership and review of deliverables.

Authorizing an outside action is a separate step from approving a deliverable. For supported actions the team designates as high-risk, irreversible, or external, the team or an authorized agent prepares an Action Card, and an authorized team member reviews it and commits the action under their own identity. Agents carry out other authorized work within the team's permissions and instructions.

FAQ

How much does it cost to build an AI agent?

Cost depends on the route. Copilot Studio use depends on the team's Microsoft licensing, and publishing needs a license that allows it. The SDK route depends on OpenAI API usage and the team's own hosting. Check current pricing pages for both before planning a rollout.

Can I create an AI agent for free?

Creating and testing are different from publishing. The Copilot Studio trial license allows creating an agent and testing it in the test chat panel, but it does not allow publishing. Installing the Agents SDK package and running a model are separate steps. Model calls use the OpenAI API and follow the account's API billing arrangements; installing the package does not establish free model access.

Can I build an AI agent without writing code?

Copilot Studio lets a maker describe the agent in plain language, edit the generated instructions, add knowledge sources, and test in a chat panel. Sharing the agent with others then depends on publishing permissions, channel access, authentication, and organization settings.

Can my team use the agent as soon as I build it?

A working prototype is a starting point. Team use adds access permissions, deployment, maintenance, and a clear owner for the agent's output. Run a wider set of test cases with the people who will use it, and decide who reviews drafts and who approves any action with outside effects.

Sources

The no-code route is based on Microsoft Learn's Copilot Studio quickstart and file knowledge guide. The code route is based on OpenAI's Agents SDK guide, Agents SDK quickstart, and guardrails and approvals guide. API charges are described on the API pricing page; access and billing need to be checked for the reader's project. The Agent Builder status comes from OpenAI's Agent Builder page and deprecations list.

The design principles in Steps 2 and 6 come from Anthropic's Building effective agents, which notes that its tooling examples have changed since December 2024; this guide draws on its principles and leaves its tool examples aside. Syfo's task records and designated-action review are described in its tasks, deliverables, and approvals documentation.