# Anatomy of an AI agent

Every AI product is built from the same few parts: the application people use, and the agent inside it, made of an LLM, a harness, tools and data, and an objective. This guide takes one apart layer by layer, shows where publishers fit, and maps about 180 products to the layer where they play.

The stack, top to bottom: **Application** → **the agent** → its four parts: **LLM** (the brain), **harness** (the program that runs it), **tools and data** (what it can reach and do, including MCP connectors), and **objective** (the job). Below each part are the products that play there.

## Application

*The application is where the human interacts with the agent.*

An application is how you use an agent: a chat app, a website, a command line, or a feature inside another product.

Example applications (not a complete list):

- **ChatGPT** (OpenAI): OpenAI’s assistant. People use it to ask, write, and research; an agent built on GPT does the work inside.
- **Claude** (Anthropic): Anthropic’s assistant for thinking, writing, and working through long documents.
- **Gemini** (Google): Google’s assistant, built into Search, Gmail, and Android.
- **Grok** (xAI): xAI’s assistant, built into X.
- **Perplexity**: An answer engine: it searches the web and answers with sources.
- **Copilot** (Microsoft): Microsoft’s assistant, inside Windows, Edge, and Office.
- **Your app**: A publisher’s own assistant, built on your catalog and your expertise. Which layers should it be yours to build?

**Market: Assistants.** General chat apps that most people meet first.

- [ChatGPT](https://chatgpt.com) (OpenAI)
- [Claude](https://claude.ai) (Anthropic)
- [Gemini](https://gemini.google.com) (Google)
- [Grok](https://grok.com) (xAI)
- [Perplexity](https://www.perplexity.ai)
- [Copilot](https://copilot.microsoft.com) (Microsoft)
- [Meta AI](https://www.meta.ai) (Meta)
- [Le Chat](https://chat.mistral.ai) (Mistral AI)
- [DeepSeek](https://chat.deepseek.com)
- [Kimi](https://www.kimi.com) (Moonshot AI)
- [Poe](https://poe.com) (Quora)
- [Gist](https://gist.ai) (ProRata)
- [Character.AI](https://character.ai)

**Market: Coding agents.** Agents that read, write, and run code.

- [Claude Code](https://www.anthropic.com/claude-code) (Anthropic)
- [Codex](https://openai.com/codex) (OpenAI)
- [GitHub Copilot](https://github.com/features/copilot) (GitHub (Microsoft))
- [Cursor](https://cursor.com) (Anysphere)
- [Windsurf](https://windsurf.com) (Cognition)
- [Devin](https://devin.ai) (Cognition)
- [Gemini CLI](https://github.com/google-gemini/gemini-cli) (Google)
- [Replit Agent](https://replit.com) (Replit)
- [Lovable](https://lovable.dev)
- [Bolt](https://bolt.new) (StackBlitz)
- [v0](https://v0.app) (Vercel)
- [Amazon Q Developer](https://aws.amazon.com/q/developer/) (Amazon)

**Market: Work and enterprise.** Agents built into the tools teams already use.

- [Microsoft 365 Copilot](https://www.microsoft.com/microsoft-365/copilot) (Microsoft)
- [Gemini Enterprise](https://cloud.google.com/gemini-enterprise) (Google)
- [Agentforce](https://www.salesforce.com/agentforce/) (Salesforce)
- [Glean](https://www.glean.com)
- [Notion AI](https://www.notion.com/product/ai) (Notion)
- [ServiceNow AI Agents](https://www.servicenow.com) (ServiceNow)
- [Sierra](https://sierra.ai)
- [Decagon](https://decagon.ai)
- [Harvey](https://www.harvey.ai)
- [Writer](https://writer.com)

**Market: Research and scholarly AI.** AI apps that find, read, and cite research and professional sources.

- [OpenEvidence](https://www.openevidence.com)
- [NotebookLM](https://notebooklm.google.com) (Google)
- [Elicit](https://elicit.com)
- [Consensus](https://consensus.app)
- [Deep research in ChatGPT](https://chatgpt.com) (OpenAI)
- [You.com](https://you.com)
- [Scopus AI](https://www.elsevier.com/products/scopus/scopus-ai) (Elsevier)
- [Web of Science Research Assistant](https://clarivate.com) (Clarivate)

### The agent

*Agents have four primary parts that make them work.*

An agent is an AI that does work instead of only answering. Every agent, from Claude Code to a publisher’s own assistant, is built from the same four parts.

#### LLM

*The LLM is the brain of the agent.*

The model, or LLM (large language model), learned to read and write from an enormous library, and then that learning was frozen. It is very good at deciding what to say or do next.

On its own it can only talk. It cannot look anything up, remember you tomorrow, or take an action. The other three parts give it those powers.

**Market: Inference and hosting.** Where models run: clouds, speed specialists, and local tools.

- [Amazon Bedrock](https://aws.amazon.com/bedrock/) (Amazon)
- [Azure AI Foundry](https://azure.microsoft.com/products/ai-foundry) (Microsoft)
- [Vertex AI](https://cloud.google.com/vertex-ai) (Google)
- [Together AI](https://www.together.ai)
- [Fireworks AI](https://fireworks.ai)
- [Groq](https://groq.com)
- [Cerebras](https://www.cerebras.ai)
- [Replicate](https://replicate.com)
- [Hugging Face](https://huggingface.co)
- [OpenRouter](https://openrouter.ai)
- [Ollama](https://ollama.com)
- [vLLM](https://github.com/vllm-project/vllm) (vLLM project)
- [Baseten](https://www.baseten.co)
- [Modal](https://modal.com)

##### Frontier models

*Frontier models are the most capable, and kept private by the labs that build them.*

A few labs build the most capable models in the world and keep them private. You reach them over the internet and pay for what you use.

Use one when quality matters most: hard reasoning, careful writing, and agents that have to get it right the first time.

- **Where it runs:** On the lab’s servers
- **Can you see inside?:** No. The weights are secret.
- **Can you retrain it?:** Only lightly, if at all
- **How you pay:** Per use

- **Claude** (Anthropic): Anthropic’s models, known for careful reasoning, writing, and long documents. (https://www.anthropic.com/claude)
- **GPT** (OpenAI): OpenAI’s models, the ones behind ChatGPT. (https://openai.com/chatgpt)
- **Gemini** (Google): Google DeepMind’s models, built into Google’s products. (https://gemini.google.com)
- **Grok** (xAI): xAI’s models, built into X. (https://x.ai)

**Market: Frontier models.** The most capable private models.

- [Claude](https://www.anthropic.com/claude) (Anthropic)
- [GPT](https://openai.com) (OpenAI)
- [Gemini](https://deepmind.google/models/gemini/) (Google)
- [Grok](https://x.ai) (xAI)
- [Amazon Nova](https://aws.amazon.com/ai/generative-ai/nova/) (Amazon)
- [Command](https://cohere.com) (Cohere)
- [Mistral Large](https://mistral.ai) (Mistral AI)

##### Open-weight models

*Open-weight models can be downloaded, run, and changed by anyone.*

Some labs publish their model’s weights, the numbers that make it work. Anyone can download one, run it on their own servers or a cloud provider, and retrain it.

They usually trail the frontier by a few months. Use one when you need control, privacy, or low cost at high volume, and the task does not need the very best.

- **Where it runs:** A cloud provider, or your own servers
- **Can you see inside?:** Yes. The weights are public.
- **Can you retrain it?:** Fully, even on your own content
- **How you pay:** For the computers that run it

- **Llama** (Meta): Meta’s open-weight family, one of the most widely used. (https://www.llama.com)
- **Mistral** (Mistral AI): A French lab that publishes efficient open-weight models. (https://mistral.ai)
- **DeepSeek**: A Chinese lab whose open models rival the frontier at low cost. (https://www.deepseek.com)
- **Qwen** (Alibaba): Alibaba’s open-weight family, strong in many languages. (https://qwenlm.github.io)
- **Gemma** (Google): Google’s small open-weight models, light enough to run almost anywhere. (https://ai.google.dev/gemma)
- **gpt-oss** (OpenAI): OpenAI’s open-weight models. (https://openai.com/open-models)

**Market: Open-weight models.** Models anyone can download, run, and retrain.

- [Llama](https://www.llama.com) (Meta)
- [Mistral](https://mistral.ai) (Mistral AI)
- [DeepSeek](https://www.deepseek.com)
- [Qwen](https://qwenlm.github.io) (Alibaba)
- [Gemma](https://ai.google.dev/gemma) (Google)
- [gpt-oss](https://openai.com/open-models) (OpenAI)
- [Phi](https://azure.microsoft.com/products/phi) (Microsoft)
- [Kimi K2](https://moonshotai.github.io/Kimi-K2/) (Moonshot AI)
- [GLM](https://z.ai) (Zhipu AI)
- [Nemotron](https://www.nvidia.com) (NVIDIA)
- [OLMo](https://allenai.org/olmo) (Ai2)

##### Data licensing

*Data licensing is how a model gets permission to learn from content.*

A model learns from an enormous library: the open web, books, journals, code, and archives. That learning is then frozen into the model.

More and more of it comes through licensing deals and paid access, rather than free crawling.

Examples: The open web; Licensed books and journals; News archives; Code; Synthetic data.

**Market: Data licensing.** Deals that license content for a model to learn from.

- [CCC AI licensing](https://www.copyright.com) (Copyright Clearance Center)
- [Created by Humans](https://www.createdbyhumans.ai)

#### Harness

*The harness is the program that runs the agent and keeps it on task.*

The harness is the program that runs the agent. It hands the model its instructions, runs it in a loop, gives it tools, and enforces the rules.

Change the harness and you get a different agent. Claude Code and Cowork use the same model, but different harnesses make them do very different work.

**Market: Agent-building platforms.** Hosted builders for designing and running agents.

- [AgentKit](https://openai.com) (OpenAI)
- [Copilot Studio](https://www.microsoft.com/microsoft-copilot/microsoft-copilot-studio) (Microsoft)
- [Bedrock AgentCore](https://aws.amazon.com/bedrock/agentcore/) (Amazon)
- [Vertex AI Agent Builder](https://cloud.google.com/products/agent-builder) (Google)
- [Agentforce](https://www.salesforce.com/agentforce/) (Salesforce)
- [n8n](https://n8n.io)
- [Zapier Agents](https://zapier.com/agents) (Zapier)
- [Relevance AI](https://relevanceai.com)
- [Dify](https://dify.ai) (LangGenius)
- [Flowise](https://flowiseai.com) (FlowiseAI)

##### Instructions

*Instructions are the standing orders the model reads first.*

Plain-language orders the model reads before it does anything: who it is, how it speaks, what it must never do.

This is where a publisher’s voice and standards live.

- **System prompt**: Who the agent is and what it is for, read before every task. Example: "You are Acme Kitchen, the cooking assistant from Acme Books. Help home cooks plan and make meals using recipes from Acme titles only."
- **Voice and tone**: How it sounds, so every answer feels like your brand. Example: "Warm and practical. Short sentences. Talk like a friend in the kitchen, not a chef on TV."
- **Do and don’t**: House standards the model should follow. Example: "Always cite the book and page. Give oven temperatures in °F and °C. Never guess about allergens; point to the label."
- **Worked examples**: A few model answers that show exactly what good looks like. Example: "Q: Can I freeze this soup? A: Yes. Cool it fully, then freeze for up to 3 months. (The Weeknight Table, p. 88)"

**Market: Prompt management.** Tools for writing, versioning, and testing instructions.

- [PromptLayer](https://www.promptlayer.com)
- [Vellum](https://www.vellum.ai)
- [Agenta](https://agenta.ai)
- [LangSmith Prompt Hub](https://smith.langchain.com) (LangChain)

##### The loop

*The loop is how the agent works through a job, step by step.*

A chatbot answers once. An agent loops: it works through the job step by step until it is done, hits a limit, or needs a person.

There is no single loop. The right one depends on the job, and these are eight common shapes.

- **Think, act, check**: The everyday loop: reason about the next step, take it, look at the result, and repeat. Use it when: A reader asks an open question, and the agent has to look around before it can answer. Steps: Think → Act → Observe.
- **Step by step**: A fixed sequence of steps, with a check between them that can stop the run early. Use it when: Turning every new chapter into a summary, then a quiz, the same way each time.
- **Routing**: Sort the request first, then send it down the path built for that kind of request. Use it when: One help desk that sends recipe questions, order problems, and rights requests to different handlers.
- **In parallel**: Split the job into parts, work on them at the same time, then combine the results. Use it when: Reviewing a long manuscript: every chapter is checked at once, then the notes are combined.
- **Manager and helpers**: One agent breaks the job down, hands pieces to helper agents, and assembles their work. Use it when: Building a reading list: the manager picks the topics and sends a helper to research each one.
- **Draft and critique**: One agent writes; another reviews against the standards and sends notes until it passes. Use it when: Writing back-cover copy that must match house style; the reviewer sends it back until it does.
- **Plan, then do**: Write the whole plan first, work through it, and re-plan when something changes. Use it when: Assembling a course pack: plan the chapters, gather each one, and re-plan if a title is unavailable.
- **Ask a person**: Pause at the moments that matter and let a person approve before acting. Use it when: Anything that spends money or grants rights, such as approving a permissions request.

**Market: Evaluation and monitoring.** Watching the loop: traces, tests, and scores.

- [LangSmith](https://www.langchain.com/langsmith) (LangChain)
- [Langfuse](https://langfuse.com)
- [Braintrust](https://www.braintrust.dev)
- [Arize](https://arize.com)
- [Weave](https://wandb.ai) (Weights & Biases)
- [Patronus AI](https://www.patronus.ai)
- [Galileo](https://galileo.ai)

##### Rules

*Rules are hard limits the model cannot talk its way past.*

Instructions ask; rules enforce. Rules are written into the harness itself, so the model cannot talk its way past them.

Examples: Ask before spending money; Quote 300 words at most; Send medical questions to a person.

**Market: Guardrails and safety.** Rules that check what goes in and comes out.

- [Guardrails AI](https://www.guardrailsai.com)
- [NeMo Guardrails](https://github.com/NVIDIA/NeMo-Guardrails) (NVIDIA)
- [Llama Guard](https://www.llama.com) (Meta)
- [Lakera](https://www.lakera.ai) (Check Point)
- [LLM Guard](https://protectai.com) (Protect AI)

##### Open-source harnesses

*Open-source harnesses give you a head start on building your own.*

You do not have to build a harness from scratch. Open-source harnesses give you the loop, the tool handling, and the memory, ready to customize.

Most of the work left is the part only you can do: your instructions and your rules.

- **LangGraph** (LangChain): Build an agent as a graph of steps you control, from LangChain. (https://www.langchain.com/langgraph)
- **OpenAI Agents SDK** (OpenAI): OpenAI’s open-source kit for agents and hand-offs between them. (https://openai.github.io/openai-agents-python/)
- **Claude Agent SDK** (Anthropic): The harness behind Claude Code, open for you to build your own agents on. (https://github.com/anthropics/claude-agent-sdk-python)
- **Google ADK** (Google): Google’s open-source Agent Development Kit. (https://google.github.io/adk-docs/)
- **CrewAI**: Teams of agents with roles that work together on a job. (https://www.crewai.com)
- **Mastra**: A TypeScript framework for agents and workflows. (https://mastra.ai)
- **AutoGen** (Microsoft): Microsoft’s open-source framework for agents that talk to each other. (https://microsoft.github.io/autogen/)
- **smolagents** (Hugging Face): Hugging Face’s small, simple library for agents that write code. (https://huggingface.co/docs/smolagents)

**Market: Open-source harnesses.** Kits for building your own agent.

- [LangGraph](https://www.langchain.com/langgraph) (LangChain)
- [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/) (OpenAI)
- [Claude Agent SDK](https://github.com/anthropics/claude-agent-sdk-python) (Anthropic)
- [Google ADK](https://google.github.io/adk-docs/) (Google)
- [CrewAI](https://www.crewai.com)
- [Mastra](https://mastra.ai)
- [AutoGen](https://microsoft.github.io/autogen/) (Microsoft)
- [Semantic Kernel](https://github.com/microsoft/semantic-kernel) (Microsoft)
- [smolagents](https://huggingface.co/docs/smolagents) (Hugging Face)
- [LlamaIndex](https://www.llamaindex.ai)
- [Pydantic AI](https://ai.pydantic.dev) (Pydantic)
- [AI SDK](https://ai-sdk.dev) (Vercel)
- [Haystack](https://haystack.deepset.ai) (deepset)
- [DSPy](https://dspy.ai) (Stanford NLP)
- [Agno](https://www.agno.com)

#### Tools and data

*Tools and data give the agent what the LLM doesn’t have: fresh information, your content, and the ability to act.*

The LLM only knows what it learned in training, and it cannot act. Tools and data reach past that: they bring in fresh information and licensed content, remember what matters, and take actions in other systems.

The model asks; the harness decides whether to allow it and makes the call.

##### Connectors (MCP)

*Connectors plug the agent into outside tools and content through one standard: MCP.*

MCP (Model Context Protocol) is one standard way to connect any agent to any outside tool or content source. It is the USB-C of AI.

Behind each plug is an MCP server, a small service that speaks the standard for one system.

**Market: MCP gateways and registries.** Places to find, host, and manage MCP servers.

- [MCP Registry](https://modelcontextprotocol.io) (Anthropic and the MCP community)
- [Smithery](https://smithery.ai)
- [Composio](https://composio.dev)
- [Pipedream MCP](https://mcp.pipedream.com) (Pipedream)
- [Zapier MCP](https://zapier.com/mcp) (Zapier)
- [Remote MCP on Workers](https://developers.cloudflare.com/agents/) (Cloudflare)

**Market: Content and research connectors.** Publisher and research content that agents reach through a connector. Any of these could launch on a publisher MCP engine.

- [Scite](https://scite.ai) (Research Solutions)
- [Dimensions](https://www.dimensions.ai) (Digital Science)
- [Semantic Scholar](https://www.semanticscholar.org) (Ai2)
- [JSTOR](https://www.jstor.org) (ITHAKA)
- [Scholar Gateway](https://www.wiley.com) (Wiley)
- [Silverchair](https://www.silverchair.com)

###### Cashmere Connect

*Cashmere Connect is the platform publishers launch their own MCP connectors on.*

Cashmere Connect is not one more MCP server. It is the platform you launch your own on.

Bring your content in any format. Cashmere runs the server, the tools, and the controls, under your name.

- **Launch your own server**: Your own branded MCP server, live without building or running any infrastructure.
- **Ingestion**: Works with every format you publish in.
- **Normalization**: Everything is converted to Omnipub, one clean format that agents can read and cite.
- **Powerful MCP tools**: Search, deep research, and more, ready for any agent to call.
- **Subscriptions**: Sell access to readers, teams, and AI companies, plan by plan.
- **Publisher controls**: Licensing, entitlements, and rights in one place: what is live, for whom, and on what terms.
- **Auth and security**: Sign-in for people and agents, and every request checked against the license.
- **Detailed reporting**: Every search, passage, and citation counted, down to the title.

**Market: Publisher MCP engines.** An engine to launch and run your own MCP server, with tools, controls, and reporting built in.

- [Cashmere Connect](https://cashmere.io/product/connect) (Cashmere)

###### Other MCP servers

*Thousands of systems already have an MCP server.*

The same plug connects agents to the tools people already use at work.

- **GitHub** (GitHub (Microsoft)): Lets an agent read code, issues, and pull requests. (https://github.com/github/github-mcp-server)
- **Google Drive** (Google): Lets an agent find and read your documents. (https://www.google.com/drive/)
- **Notion**: Lets an agent search and update team notes and wikis. (https://www.notion.com)
- **Slack** (Slack (Salesforce)): Lets an agent read and post team messages. (https://slack.com)
- **Figma**: Lets an agent read designs and their details. (https://www.figma.com)
- **Stripe**: Lets an agent look up payments and customers. (https://docs.stripe.com/mcp)
- **Scholar Gateway** (Wiley): Wiley’s connector to its scholarly content. (https://www.wiley.com)
- **Scite** (Research Solutions): Lets an agent see how research papers cite each other. (https://scite.ai)

**Market: MCP servers.** Everyday systems an agent can plug into.

- [GitHub](https://github.com/github/github-mcp-server) (GitHub (Microsoft))
- [Google Drive](https://www.google.com/drive/) (Google)
- [Slack](https://slack.com) (Slack (Salesforce))
- [Stripe](https://docs.stripe.com/mcp)
- [Notion](https://www.notion.com)
- [Jira and Confluence](https://www.atlassian.com) (Atlassian)
- [Linear](https://linear.app)
- [Sentry](https://sentry.io)
- [Figma](https://www.figma.com)
- [Shopify](https://shopify.dev)
- [Supabase](https://supabase.com)
- [HubSpot](https://www.hubspot.com)
- [Box](https://www.box.com)

##### Licensed content

*Licensed content gives an agent access to publisher content on the publisher’s terms, whatever it is used for.*

Instead of scraping the web, an agent can reach publisher content through a licensed gateway. The publisher sets the terms, the rules are checked on every request, and every use can be paid for, whatever the agent uses it for.

- **Cashmere Fiber** (Cashmere): The license-aware AI search gateway: get discovered by AI, without giving up control. (https://cashmere.io/product/fiber)
- **TollBit**: Agents pay a toll to fetch a publisher’s pages. (https://tollbit.com)
- **Pay per crawl** (Cloudflare): Cloudflare charges AI crawlers to fetch the sites it serves. (https://www.cloudflare.com)

**Market: Licensed content.** Access to publisher content on the publisher’s terms, with the rules enforced on every request.

- [Cashmere Fiber](https://cashmere.io/product/fiber) (Cashmere)
- [TollBit](https://tollbit.com)
- [Pay per crawl](https://www.cloudflare.com) (Cloudflare)

##### Memory

*Memory is what the agent knows about this job, and the last one.*

A model forgets everything between calls. Memory is what the harness hands back to it each time: the conversation so far, notes from last time, or a shared knowledge base.

Examples: This conversation; Notes from last time; A team knowledge base.

- **Conversation**: Everything said so far in this chat, sent back to the model each turn. Example: "You said earlier the guest is allergic to nuts."
- **Long-term memory**: Facts it keeps about you between conversations. Example: "Remember that I prefer metric units."
- **Knowledge base**: Your own documents, searched for the passages that matter right now. Example: "What does our style guide say about headlines?"
- **Working notes**: A scratchpad the agent writes to while it works through a long job. Example: "Step 3 of 7 done; two sources still to check."
- **Context window**: How much the model can hold at once. Anything beyond it must be fetched again. Example: "Long reports are read in parts, not all at once."

**Market: Memory and vector stores.** Where agents keep and find what they know.

- [Pinecone](https://www.pinecone.io)
- [Weaviate](https://weaviate.io)
- [Qdrant](https://qdrant.tech)
- [Chroma](https://www.trychroma.com)
- [Milvus](https://milvus.io) (Zilliz)
- [Atlas Vector Search](https://www.mongodb.com/products/platform/atlas-vector-search) (MongoDB)
- [pgvector](https://github.com/pgvector/pgvector) (Open source)
- [Mem0](https://mem0.ai)
- [Zep](https://www.getzep.com)
- [Letta](https://www.letta.com)

##### Built-in tools

*Built-in tools come with the harness: the agent can use them without any setup.*

The basic abilities most harnesses ship with, so an agent can look things up and get work done from day one.

Examples: Search the web; Browse a site; Run code; Read a file; Use a computer; Make an image.

- **Web search**: Look up what is happening now, beyond what the model learned in training. Example: "What did the central bank decide this morning?"
- **Web browsing**: Open a page, read it, click through, and fill in forms. Example: "Find the return policy on this store’s site."
- **Code**: Run code to calculate, analyze data, or draw a chart. Example: "Chart our monthly sales from this spreadsheet."
- **Files**: Read the PDFs, spreadsheets, and documents you hand it. Example: "Summarize the contract I just uploaded."
- **Computer use**: Use a screen, keyboard, and mouse the way a person would. Example: "Book the meeting room in our calendar app."
- **Images**: Create or edit pictures from a description. Example: "Make a cover sketch for this chapter."

**Market: Search and browsing.** Web search, scraping, and browsers built for agents.

- [Tavily](https://www.tavily.com)
- [Exa](https://exa.ai)
- [Brave Search API](https://brave.com/search/api/) (Brave)
- [Sonar API](https://sonar.perplexity.ai) (Perplexity)
- [SerpApi](https://serpapi.com)
- [Firecrawl](https://www.firecrawl.dev)
- [Jina Reader](https://jina.ai) (Jina AI)
- [Browserbase](https://www.browserbase.com)
- [Browser Use](https://browser-use.com)

**Market: Code sandboxes.** Safe places for an agent to run code.

- [E2B](https://e2b.dev)
- [Daytona](https://www.daytona.io)
- [Modal Sandboxes](https://modal.com) (Modal)

#### Objective

*The objective is the job, and what done looks like.*

The objective is the job to be done and what finished looks like. Without one, the loop would never know when to stop.

Part of it comes from the person asking. Part of it comes from the agent’s purpose, set by whoever built it.

Examples: Plan a nut-free dinner for six; Summarize this year’s research on sleep; Fix the failing test.

Interactive version: https://cashmere.io/resources/learning-center/anatomy-of-an-agent

---

This is the agent-facing markdown version of [https://cashmere.io/resources/learning-center/anatomy-of-an-agent](https://cashmere.io/resources/learning-center/anatomy-of-an-agent). Full index of agent-readable pages: https://cashmere.io/llms.txt