# Agent Builder stops at the tenant; an open-source agent is a file

> Copilot Agent Builder lets anyone with access describe an agent, ground it in SharePoint files or web content, and share it inside Microsoft 365. What it produces is a configuration in your tenant. Kortix is the open-source AI Operating System: your agents, their skills, your company memory, and every connector in one git repo you own.

URL: https://opensourcecopilotalternative.com/copilot-agent-builder

## The whole agent, quoted from the file

`agents/kortix.md`

```yaml
---
description: "Generic Kortix general knowledge worker. Hands-on, full tool access, handles coding / research / content / ops / data tasks end-to-end in an isolated session sandbox. Edit this file to specialize for your project."
mode: primary
permission: allow
---
You are a **Kortix general knowledge worker** for **{{projectName}}**.
```

Source: https://github.com/kortix-ai/suna/blob/dev/packages/starter/templates/base/agents/kortix.md

The starter's front-door agent: frontmatter for mode and permission, then the prompt. Everything else the project registers sits in kortix.yaml.

## Where the agent lives, and what you can do with it

Both build from instructions and knowledge; only one hands you the definition as a file.

| | Kortix (recommended) | Microsoft Agent Builder |
| --- | --- | --- |
| Open source | Yes | No |
| Where the agent definition lives | A markdown file and its kortix.yaml block, in your repo | A configuration in your Microsoft 365 tenant |
| Versioning and review | Git history, a change request, a person's approval | Agent inventory in the Microsoft 365 admin center |
| Where it runs | Kortix Cloud, your VPC, or your own on-prem network | Copilot's orchestrator and model, inside Microsoft 365 |
| Model choice | Any model provider with your own keys | Copilot's foundation models; no model setting in the builder |
| Self-hosting | Self-host is free | No extra hosting; Microsoft 365 only |

## What Agent Builder builds, and who it is for

Copilot Agent Builder is the no-code surface inside the Microsoft 365 Copilot app. It opens from microsoft365.com/chat, office.com/chat and the Teams desktop and web clients. It exists for the quick case: an agent that answers from a team's SharePoint files or from web content. You build it in a conversation and test it on a Try it tab before anyone shares it ([Agent Builder overview](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agent-builder)).

Microsoft draws the boundary itself. Agent Builder is aimed at individuals and small teams building "lightweight Q&A agents with organizational knowledge". Copilot Studio is for departments, external customers, multi-step workflows and application lifecycle management ([choosing between the two](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/copilot-studio-experience)). Agent Builder is included with a Microsoft 365 Copilot add-on, and Microsoft offers it free for agents grounded on web knowledge only. A person can have something useful on the first day, which is what an on-ramp is for.

Two lines on the same page matter more than the feature list. Agent Builder "doesn't support authoring actions that integrate external services" ([same page](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agent-builder)). The documented next step for low-code actions, connectors or workflows is a copy of the agent into Copilot Studio. Skills are in preview, limited to organizations in the Microsoft Frontier Program. The known limitations include no use in Teams group or 1:1 chats (checked October 2026).

## Where the agent lives, and who can take it along

An Agent Builder agent is a configuration in the tenant. Administrators see it in the Microsoft 365 admin center under Copilot > Agents and can enable, disable, assign, block or remove it ([Agent Builder overview](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agent-builder)). Microsoft notes that these agents do not consume the tenant's Dataverse storage entitlement. Prompts, instructions, configurations and output content can flow between Microsoft 365 and Copilot Studio in both directions, because Copilot Studio processes the capabilities ([data processing](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agent-builder)).

The arrangement is coherent for a Q&A agent about one team's documents, and it is why the builder is easy to hand out. It also means the agent is a set of settings an administrator governs, rather than a document a reviewer reads line by line.

## What happens to the agent when the person who built it leaves?

It stays in the tenant. The person who described the agent does not own it. The administrator's inventory does not depend on that account, so the agent stays available, reassignable or removable as the organization decides. [/copilot-agent-management](/copilot-agent-management) goes through the policy side of that.

Access follows the same logic. Microsoft says the capabilities you can add depend on what is assigned in the tenant ([Agent Builder overview](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agent-builder)). A change there changes what the agent can do. Nothing about the agent travels out with the team that built it.

## Moving an agent out of Agent Builder takes a second build

Microsoft documents one hand-off: a copy into Copilot Studio. It preserves the agent's core configuration and instructions and lands it under Power Platform administration in the same tenant ([comparison](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/copilot-studio-experience)). What a Copilot Studio agent is once it lands there is [/copilot-studio-agent](/copilot-studio-agent). A team that wants an agent hosted outside Microsoft 365 takes Microsoft's custom engine route, which means bringing its own orchestrator and models and hosting them ([agents overview](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agents-overview)). That is building the agent again, in a different runtime.

## The same agent as a file in a repo you own

Kortix is the open-source AI Operating System, and its agents are files. The starter ships a front-door agent as `agents/kortix.md`: frontmatter that sets the mode and the permission, then the prompt itself. The artifact above is the opening of that file. The manifest beside it registers what exists: the agents, skills, tools and connectors the project has, and which of them each agent may use. Behavior lives in the markdown, governance in `kortix.yaml`, and both are in git history.

A session starts from that repository. One isolated sandbox per session. Each session has its own isolated machine and branch. The agent reads, edits, runs and tests there, and only what it commits and pushes survives.

When the work is ready, it does not land by itself. Session work reaches `main` through a change request. Merge is default-deny for agents. A reviewer opens the change request and reads the diff of the definition. That diff carries the instruction that changed, the model, the permission, the connector the agent now enables by name. Approving it is the same act as approving a code change, with the same history behind it.

That is the difference that matters once an agent encodes a process rather than answering questions about one. In Agent Builder, governance is an inventory screen and a set of admin actions. In Kortix, governance is a diff, and the thing under review is the agent. The control plane Microsoft sells on top of the builder gets its own page at [/microsoft-agent-365](/microsoft-agent-365).

## Where it runs, and on which model

Run it on Kortix Cloud, in your VPC, or on your own on-prem network. Self-host is free. Any model provider with your own keys. Or the ChatGPT plan you already pay for. Or sign in with your OpenCode Console account for OpenCode Zen and Go.

Agent Builder makes the opposite trade. A declarative agent runs on Copilot's orchestrator and foundation models, and customization is "limited to Copilot's orchestrator and models" ([agents overview](https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/agents-overview)). The convenience is real, and the model comes with the tenancy.

## A fair reading of both

If an agent answers questions about documents that already live in Microsoft 365, and the people asking sit inside the tenant, Agent Builder is the shortest route to a working answer. Copilot Studio is there when the scope grows. If the agent is meant to carry a process the company will still need in three years, on models the company chooses, the definition has to live somewhere the company controls. A file in a repository is that place, and reviewing it is a habit the team already has for code.

## Questions buyers ask before they build

### What is Microsoft Copilot Agent Builder?

A no-code builder inside Microsoft 365 Copilot. You describe an agent, give it knowledge from SharePoint or web content, test it and share it; Microsoft calls the result a declarative agent.

### Is Copilot Agent Builder free?

Yes, for agents grounded on web knowledge only. Other agents need a Microsoft 365 Copilot add-on; without one, Microsoft points to Copilot Credits or a pay-as-you-go plan (checked October 2026).

### What is the difference between Agent Builder and Copilot Studio?

Agent Builder is the quick, no-code surface for individuals and small teams. Copilot Studio is a standalone portal for department-wide agents, multi-step workflows, connectors and lifecycle management, and an Agent Builder agent can be copied into it.

### Can an agent built in Agent Builder run outside Microsoft 365?

No. The documented hand-off is a copy into Copilot Studio, another Microsoft service in the same tenant. Running elsewhere means building the agent again, on Microsoft's custom engine route or another system.

## Keep the agent definition in a repo your team reviews

Describe the agent once, then read the file it becomes.

[Try Kortix](https://kortix.com)