Skip to main content
How Do Models Do More Than Just Answer Questions? So far, we’ve looked at how models are trained, how you prompt them, and how they retrieve helpful context. Now let’s explore the next level of capability: what happens when models begin to act, plan, or chain together multiple steps. This section covers application patterns: ways AI systems are built to do more than answer a single prompt, from using tools to working on their own for a while.

Agent

What it means: An agent is an AI system that takes actions on your behalf, observing, planning, and executing steps toward a goal you set. Analogy: If a single prompt is like asking a question, an agent is like assigning a task. Agents decide which steps to take, and in what order, to complete something more complex. Use case: You ask an agent to “prepare a report on our website traffic.” It might search your data, summarize the results, and send you a document, all without another prompt. How it shows up in Gloo: Gloo Code is a coding agent: it plans, writes, and tests code changes. On the API, you can build your own agents by combining tool use, reasoning, and grounded answers from your content. Go deeper: Coding Agents shows the loop an agent runs to finish a whole task.

Autonomous Agent

What it means: An autonomous agent can operate over longer periods without user input. It can keep track of goals, retry failed steps, and decide what to do next on its own. Why it matters: Autonomous agents move AI from reactive to proactive: they can keep working in the background toward a goal. Caution: Autonomy introduces risk. These systems need clear constraints, guardrails, and oversight to prevent unwanted behaviors. How it shows up in Gloo: Gloo Code can run on its own, including headless in scripts, working through a task step by step. When you build your own agent on the API, you decide which tools it can use and when a person needs to approve its actions. Go deeper: Coding Agents covers what changes when an agent runs without a person watching.

Tool Use (or Function Calling)

What it means: Tool use lets the AI ask your app to run a specific function or API during a conversation. Tools do things the model can’t do on its own, like look up live data, send messages, or update a calendar. The model chooses the tool and its inputs; your app runs it and sends back the result. Example: If a user asks, “What’s the weather in Kansas City right now?” the model can call a weather API to get the answer. It didn’t guess; it used a tool. Why it matters: Tool use connects AI to the rest of your software. It makes AI more useful, more accurate, and able to act on real data. How it shows up in Gloo: Gloo AI supports tool use on the Responses and Completions endpoints, with the standard OpenAI function format. You define the tools; the model decides when to call them. Tools, Structured Output and Agents covers checking each call and limiting what an agent can do. Go deeper: Tools and MCP shows how to let a model call your functions, step by step.

Orchestration

What it means: Orchestration is the coordination layer that decides what the model (or agent) does next. It might mean chaining multiple tools together, switching between models, or managing memory across steps. Analogy: Think of orchestration as a conductor leading a band of agents, models, and tools, so each one comes in at the right time and in the right order. Use case: In a customer service flow, orchestration might send one request to a document summarizer, another to a live agent, and another to a scheduling assistant, all automatically. How it shows up in Gloo: A grounded request on Gloo AI is a simple example of orchestration: in one call, Gloo searches your uploaded content, passes the best passages to the model, and returns a grounded answer. On Guarded Completions and Grounded Completions, opt-in auto-routing also picks a model for each request.

Chain of Thought (CoT)

What it means: Chain of thought is a model working through a problem step by step instead of jumping straight to an answer. You can ask for it in a prompt, and reasoning models do it on their own before they answer. Why it helps: People solve hard problems by breaking them into steps, and models do better when they “think aloud” the same way. It improves results on complex tasks like math, logic, and planning. Go deeper: Think Step by Step shows how to ask for reasoning, and Models That Think Before They Answer covers models that do it on their own.

Memory

What it means: Memory is the model’s ability to retain relevant information between interactions. Unlike the context window (which is temporary), memory can persist across sessions. Use case: A chatbot with memory might remember your name, preferences, or past questions, even days later.
Memory is often implemented using external storage (like a database), not inside the model itself.
How it shows up in Gloo: Gloo AI’s model endpoints don’t remember earlier requests: your app sends the conversation it wants the model to see with each request. For longer-term knowledge, the Data Engine stores your organization’s content and metadata, which grounded endpoints can draw on. Go deeper: Conversations That Remember shows how your app keeps a conversation going across turns.

Guardrails

What it means: Guardrails are safety rules or constraints around AI behavior. They define what the model can and cannot do, say, or access. Examples:
  • Blocking certain topics
  • Preventing sensitive data from being generated
  • Requiring multiple confirmations before triggering actions
Why it matters: As AI gets more powerful, especially in agent or autonomous settings, guardrails help maintain safety and trust. How it shows up in Gloo: Guardrails are central to Gloo AI. The guarded endpoints run guardrails on each request and moderate each response, and they can give values-aligned responses with the tradition setting. You get these with any model you choose. Direct endpoints add none of this, for apps that handle safety themselves. Go deeper: Guardrails and Values explains what guarded endpoints handle for you and what your app still owns.
Try it on Gloo: let a model call your own functions with Tool Use, and set how much a model reasons before it answers with Reasoning.

What’s next

To build these patterns with Gloo’s API, follow the Completions with Tool Use tutorial and read Tools, Structured Output and Agents.

What Are the Risks and Challenges of AI, and How Can We Use It Responsibly?

What limitations, risks, and safety concerns come with modern AI, and how do we address them with care and responsibility?