# Agents

Canonical: [https://subcore.ai/core0/agents](https://subcore.ai/core0/agents)

Core0 agents handle open-ended work: hand one a goal and tools and it works out the steps itself. Great for Q&A, research, and troubleshooting, and it composes with orchestration, handoffs, memory, and retrieval.

## Hero
- Core0 · Agents
- Agents that find their own path.
- Hand an agent a goal and a set of tools, and it works out the steps for itself. Open-ended by design, for the work you couldn't script in advance.
- Book a Demo
- See Flow Agents

## The idea
- You hand an agent a goal and a set of tools. It decides what to do next, and talks like a person the whole way.

## Built for the work you can't script.

An agent is the colleague you trust to think on their feet. Give it a goal and the tools to reach it, and it works out the rest, one turn at a time.

### Thinks on its feet

Give it a goal and tools, and it decides what to do next from the conversation so far. No script required.

#### Details

You describe the goal, hand over the tools, and the agent works out the steps for itself. This is exactly what you want when the path can’t be known ahead of time.

It’s at its best on open-ended work:

#### Q&A and research

Open-ended

Answer anything about your product, dig through sources, summarize, compare.

#### Troubleshooting

Branching

Each next step depends on the last answer. The agent discovers the path as it goes.

### Reaches for the right tool

The model calls the tools it needs, when it needs them. Search, look something up, take an action, then keep going.

#### Details

Tools are first-class in Core0. You declare what an agent can do, and the model decides when to use each one. It can pull live data, call your APIs, or trigger a real action mid-conversation.

Exposure is yours to control. A tool can be always on, gated behind a condition, or offered for a single turn and then withdrawn. The agent only ever sees the tools you allow, so it can’t reach for the wrong one.

### Composes with the whole framework

The same primitive sits behind multi-agent orchestration, safe handoffs, memory, and retrieval. One agent or a team of them.

#### Details

An agent is rarely alone. Core0 can route each request to the best-suited agent, let specialists hand off to one another mid-conversation, and ground every answer in your own data through retrieval.

Memory, tools, and telemetry come from the same foundation, so a single agent and a coordinated team behave consistently and stay observable in production.

### Brings in a human when it counts

When the agent reaches the edge of what it should do alone, it can hand off to a person with the whole conversation in hand.

#### Details

Autonomy has limits, and an agent should know them. Core0 lets an agent escalate cleanly to a teammate, passing along the full history so the person picks up exactly where the conversation left off.

When automation is ready to take over again, control comes back with the human transcript in context. Nothing is lost in the handoff, either direction.

## When the path is fixed, reach for a Flow Agent
- An agent is often the front door. It greets, works out what the caller wants, and routes anything procedural to a Flow Agent. Open-ended where you want range, structured where you want guarantees.
- See Flow Agents
- The agent greets and routes
- It handles the open-ended turns, figures out intent, and decides where the conversation should go next.
- The flow runs the procedure
- Once a task has a fixed path and required data, control hands off to a Flow Agent that sees it through.

## One foundation
- Agents and flow agents, built on the same operating layer for production AI.
- Memory, tools, telemetry, and human oversight come from one runtime. Build the open-ended half as an agent, the procedural half as a flow agent, and ship them together.
- Book a Demo
- Explore Core0