# Agent OS Foundations ### About this export | Field | Value | | --- | --- | | **content_type** | course | | **platform** | contentstack-academy | | **source_url** | https://www.contentstack.com/academy/courses/agentos-foundations | | **language** | en | | **product_area** | Contentstack Academy | | **learning_path** | standalone | | **course_id** | agentos-foundations | | **slug** | agentos-foundations | | **version** | 2026-06-08 | | **last_updated** | 2026-06-19 | | **status** | published | | **keywords** | ["Contentstack Academy"] | | **summary_one_line** | Agent OS Foundations introduces the core concepts behind Contentstack Agent OS and provides the knowledge needed to begin building AI-powered solutions. You'll learn how agents differ from automations, how Polaris fits i… | | **total_duration_minutes** | 27 | | **lessons_count** | 7 | | **video_lessons_count** | 7 | | **text_lessons_count** | 0 | | **linked_learning_path** | standalone | | **linked_assessment_ref** | LMS_UNCONFIGURED_COURSE_ASSESSMENT | | **markdown_file_url** | /academy/md/courses/agentos-foundations.md | | **generated_at** | 2026-06-19T08:30:58.327Z | | **intended_audience** | [] | | **prerequisites** | [] | | **related_courses** | [] | > **Academy MD v3** — companion `.md` for Ask AI. Quizzes and graded assessments are **LMS-only**; this file never contains answer keys. ## Course Overview | Metadata | Value | | --- | --- | | Catalog duration | 26m 40s | | Released (if known) | 2026-06-08 | | Product area | Contentstack Academy | ### Description Agent OS Foundations introduces the core concepts behind Contentstack Agent OS and provides the knowledge needed to begin building AI-powered solutions. You'll learn how agents differ from automations, how Polaris fits into the Agent OS ecosystem, and how triggers, tools, instructions, and models work together to create intelligent workflows. Through practical examples and real-world scenarios, you'll explore the types of problems agents are designed to solve, understand when to use agents versus automations, and develop the mental models needed to design effective agentic systems. By the end of this course, you'll understand the fundamental building blocks of Agent OS and be prepared to build your first working agent in the next course. ### Overview Learn the core concepts behind Contentstack Agent OS. In this course, you'll explore agents, automations, Polaris, triggers, tools, instructions, and models, while learning how these components work together to create intelligent workflows. By the end of the course, you'll have the foundation needed to build your first agent with Agent OS. ### Learning objectives 1. Follow each lesson in order. 2. Practice in a training stack using placeholders **YOUR_STACK_API_KEY** and **YOUR_DELIVERY_TOKEN** in local `.env` files only. 3. Validate API responses against the official documentation. ### Topics covered Contentstack Academy ## Course structure ```text agentos-foundations/ ├── 01-welcome-to-agent-os · video · 220s ├── 02-agents-vs-automations · video · 252s ├── 03-the-anatomy-of-an-agent · video · 258s ├── 04-what-makes-a-good-agent-problem- · video · 268s ├── 05-what-makes-a-bad-agent-problem- · video · 230s ├── 06-designing-an-agent-workflow · video · 247s ├── 07-how-agent-os-components-work-together · video · 125s ``` ## Lessons ### Lesson 01 — Welcome to Agent OS #### Video details #### At a glance - **Title:** Welcome to AgentOS - **Duration:** 3m 40s - **Media link:** https://cdn.jwplayer.com/previews/q7pHDK0A - **Publish date (unix):** 1780928306 #### Streaming renditions - application/vnd.apple.mpegurl - audio/mp4 · AAC Audio · 113692 kbps - video/mp4 · 180p · 180p · 183448 kbps - video/mp4 · 270p · 270p · 231885 kbps - video/mp4 · 360p · 360p · 281347 kbps - video/mp4 · 406p · 406p · 302743 kbps - video/mp4 · 540p · 540p · 389006 kbps - video/mp4 · 720p · 720p · 530554 kbps - video/mp4 · 1080p · 1080p · 887399 kbps #### Timed text tracks (delivery) - **thumbnails:** `https://cdn.jwplayer.com/strips/q7pHDK0A-120.vtt` #### Video transcript Over the last several years, artificial intelligence has moved from a specialized technology used by a handful of experts to something many of us interact with every day. We ask questions, we generate content, we summarize information, and we brainstorm ideas. For many people, AI has become another tool in the workplace. But something interesting is beginning to happen. Organizations are starting to move beyond simply asking AI for answers. They're beginning to ask a different question. What if AI could perform work, not just generate content, not just answer questions, but actually participate in workflows, use tools, gather information, make decisions, and help accomplish meaningful business objectives? That's where agentic systems enter the picture. An agentic system is designed around outcomes. Instead of simply responding to a prompt, it can work towards a goal using the capabilities available to it. It can gather information, evaluate options, take action, and produce results. This shift is important because many of the challenges organizations face today aren't really information problems. They're workflow problems. Teams spend time researching information, creating summaries, reviewing content, monitoring trends, coordinating approvals, and moving work between different systems. These activities create value, but they also consume time and attention. Agentic systems provide a new way to approach that work, not by replacing people, but by helping people focus on higher-value activities. AI assistants can help with research, analysis, content generation, and other forms of knowledge work. AgentOS is ContentStack's platform for building these types of solutions. It provides the framework for creating systems that can respond to events, use tools, follow instructions, interact with content, and help organizations accomplish work more efficiently. But before we start building anything, we need to develop the right mental model. Because successful agent projects rarely fail because of technology. More often, they fail because the problem wasn't clearly understood. Or because the wrong solution was applied to the wrong type of work. That's why this course focuses on foundations. We'll explore how agentic systems differ from traditional automation. We'll examine the types of problems agents are well-suited to solve. We'll discuss the building blocks that make agents work. And we'll introduce a practical framework for thinking about agent design. By the end of this course, you should have a solid understanding of what AgentOS is, how agentic systems operate, and how to identify opportunities where agents can create meaningful value. So, let's begin by exploring one of the most important distinctions in AgentOS – the differences between agents and automations. #### Key takeaways - Connect **Welcome to Agent OS** back to your stack configuration before moving to the next module. - Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment. - Re-read the delivery versus management boundary for anything you changed in the entry model. ### Lesson 02 — Agents vs Automations #### Video details #### At a glance - **Title:** Agents vs Automations - **Duration:** 4m 12s - **Media link:** https://cdn.jwplayer.com/previews/K1x64ULw - **Publish date (unix):** 1780928262 #### Streaming renditions - application/vnd.apple.mpegurl - audio/mp4 · AAC Audio · 113770 kbps - video/mp4 · 180p · 180p · 175497 kbps - video/mp4 · 270p · 270p · 217438 kbps - video/mp4 · 360p · 360p · 256553 kbps - video/mp4 · 406p · 406p · 272259 kbps - video/mp4 · 540p · 540p · 346673 kbps - video/mp4 · 720p · 720p · 456447 kbps - video/mp4 · 1080p · 1080p · 729919 kbps #### Timed text tracks (delivery) - **thumbnails:** `https://cdn.jwplayer.com/strips/K1x64ULw-120.vtt` #### Video transcript We just talked about the idea that agents and automations are different. Now let's explore exactly what that means. Because one of the biggest mistakes organizations make when they first start working with AI is trying to use an agent for everything. In reality, automations and agents solve different problems. Let's start with automation. Most automation platforms operate using a very simple model. Something happens, a trigger fires, then a predefined sequence of actions executes. For example, imagine a content editor publishes an entry. When that happens, we might automatically send a Slack message, update a project board, and notify a stakeholder. Every step is known ahead of time. The workflow is predictable. If the same trigger happens tomorrow, the exact same steps will execute again. That makes automations powerful, it's reliable, it's repeatable, and it's often the right solution. But, now let's look at a different problem. Suppose I ask a system to find the most important AI stories from this week, summarize each one, explain its impact on digital experiences, create content entries for the findings, and then notify my team. Suddenly, the workflow becomes much less predictable. The system may need to search different sources. It might discover different stories. It may decide one story is more important than the other. It may need to generate different summaries every time it runs. This is where agents become valuable. Instead of following a fixed sequence of steps, an agent is given an objective. The agent then determines how to achieve that objective using the tools and instructions available to it. The important distinction is that the desired outcome stays the same, but the path may change. That's a fundamentally different way of thinking about software. One of the useful ways to think about this is, automations know how, agents know what. An automation already knows exactly how a task should be completed. An agent knows what outcome you're trying to achieve and has the flexibility to determine how to get there. Now, that flexibility is powerful, but it also introduces tradeoffs. Automations are highly predictable. Agents are adaptive. Automations are easy to test because the workflow rarely changes. Agents can produce different outputs based on the information they discover and the decisions they make. That's why the question isn't whether agents replace automations. The question is when to use each. If the workflow is straightforward, repeatable, and requires consistency, automation is usually the better choice. If the workflow involves research, analysis, content generation, decision support, or other forms of knowledge work, an agent may be the better fit. In practice, the most successful organizations often combine both approaches. An agent determines what needs to happen, and automation handles the predictable operational work. Together, they create systems that are both intelligent and reliable. As we move through these series of courses, you'll see this pattern repeatedly. The goal isn't to replace every automation with an agent. The goal is to identify the right problems for agents to solve. #### Key takeaways - Connect **Agents vs Automations** back to your stack configuration before moving to the next module. - Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment. - Re-read the delivery versus management boundary for anything you changed in the entry model. ### Lesson 03 — The Anatomy of an Agent #### Video details #### At a glance - **Title:** The Anatomy of an Agent - **Duration:** 4m 18s - **Media link:** https://cdn.jwplayer.com/previews/SRncMVcH - **Publish date (unix):** 1780928292 #### Streaming renditions - application/vnd.apple.mpegurl - audio/mp4 · AAC Audio · 113798 kbps - video/mp4 · 180p · 180p · 174085 kbps - video/mp4 · 270p · 270p · 211619 kbps - video/mp4 · 360p · 360p · 248119 kbps - video/mp4 · 406p · 406p · 265993 kbps - video/mp4 · 540p · 540p · 336960 kbps - video/mp4 · 720p · 720p · 441127 kbps - video/mp4 · 1080p · 1080p · 728587 kbps #### Timed text tracks (delivery) - **thumbnails:** `https://cdn.jwplayer.com/strips/SRncMVcH-120.vtt` #### Video transcript Now that we understand the differences between agents and automations, let's look at the building blocks that make agents work. One of the things I appreciate about AgentOS is that the architecture is actually pretty straightforward. Every agent is built from four core components, a trigger, a set of tools, instructions, and an AI model. If you understand those four things, you understand the foundation of every agent you'll build. Let's start with triggers. A trigger answers a very simple question, what starts the agent? Every agent needs some event that tells it it's time to begin working. In the examples we'll use throughout the next course, it's a CMS trigger. When that trigger is called, the agent wakes up and begins executing its workflow. Think of the trigger as the starting line. Without it, the agent never runs. Next we have tools. Tools answer a different question, what can the agent do? An agent without tools is a lot like a very smart employee locked in an empty room. It might understand the task, it might know what it needs to happen, but it has no way to interact with the outside world. Tools provide those capabilities. For example, an agent might have access to web search. It might be able to create content inside of Content Stack. It might be able to send a message through Slack. The tools define the actions available to the agent. The more important question isn't how many tools an agent has, it's whether the agent has the right tools for the job. Now let's talk about instructions. If triggers determine when an agent runs and tools determine what it can do, instructions determine what it's trying to accomplish. Instructions are arguably the most important part of the agent. They establish the role, the objective, the constraints, and the expected output. For example, we might tell an agent, find the three most important AI news stories from the last seven days, summarize each one, explain the potential impact on digital experience, create content entries, and notify the marketing team. Those instructions provide direction. Without instructions, the agent has no objective. Finally, we have the AI model. The AI model is the reasoning engine behind the agent. It's responsible for understanding the instructions, deciding how to use the available tools, evaluating information, and generating outputs. In many ways, the model is the brain of the operation. The trigger starts the work. The tools provide the capabilities, the instructions provide direction, and the model provides the reasoning. When all four components come together, we get an agent capable of accomplishing meaningful tasks. Let's use a news intelligence agent as an example. The trigger starts the process. The web search tool finds relevant information. The content stack tool creates entries. The Slack tool sends notifications. The instructions define what success looks like. And the AI model determines how to use those capabilities to achieve the objective. Notice something important? The magic isn't in any single component. The value comes from how these pieces work together. A great model with poor instructions produce poor results. Great instructions without the right tools produce poor results. The best agents are designed as complete systems. And that's exactly what we're going to learn about over the next few courses. #### Key takeaways - Connect **The Anatomy of an Agent** back to your stack configuration before moving to the next module. - Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment. - Re-read the delivery versus management boundary for anything you changed in the entry model. ### Lesson 04 — What Makes a Good Agent Problem? #### Video details #### At a glance - **Title:** What Makes a Good Agent Problem - **Duration:** 4m 28s - **Media link:** https://cdn.jwplayer.com/previews/MEOS95j0 - **Publish date (unix):** 1780928329 #### Streaming renditions - application/vnd.apple.mpegurl - audio/mp4 · AAC Audio · 113728 kbps - video/mp4 · 180p · 180p · 171755 kbps - video/mp4 · 270p · 270p · 207456 kbps - video/mp4 · 360p · 360p · 240245 kbps - video/mp4 · 406p · 406p · 256858 kbps - video/mp4 · 540p · 540p · 324055 kbps - video/mp4 · 720p · 720p · 419289 kbps - video/mp4 · 1080p · 1080p · 689688 kbps #### Timed text tracks (delivery) - **thumbnails:** `https://cdn.jwplayer.com/strips/MEOS95j0-120.vtt` #### Video transcript Let's talk about something that often gets overlooked. Just because you can build an agent doesn't mean you should. In fact, one of the most valuable skills you'll develop as an agent designer is knowing when not to build one. Before you ever open AgentOS, before you ever create a project, before you configure a trigger, you should ask yourself a simple question. Is this actually an agent problem? Because agents are incredibly powerful, but they're not the right solution for every situation. Let's look at the types of problems where agents tend to excel. The first category is research. Anytime a task involves finding information, evaluating information, and synthesizing information, agents can be incredibly effective. Think about competitive analysis or industry monitoring, trend identification, market research. These aren't tasks where every execution follows the same path. The information changes constantly. The agent has to adapt. The second category is analysis. Suppose you have a collection of support tickets and you want to identify emerging themes, or maybe you have customer feedback and you want to identify common pain points. The value isn't in retrieving the information, the value is in understanding it. That's exactly the kind of work that agents are good at. The third category is decision support. Notice, I didn't say decision making, I said decision support. An agent can gather information, identify patterns, highlight risks, and provide recommendations. But the final decision often remains with a human. This is one of the most common and quite frankly valuable applications of AI inside organizations today. The fourth category is content creation. Drafting summaries, creating reports, generating descriptions, producing first drafts. Again, these are situations where the desired outcome is known, but the exact path to get there isn't. Now let's look for a common thread. What do all of these examples have in common? Well, first, there are multiple possible paths to success. Second, information gathering is usually required. Third, some amount of judgment or reasoning is involved. And fourth, the output can vary from one execution to the next. That's important. If every execution should produce exactly the same result, an agent may not be the best choice. A useful test I often use is this. Can I define the goal more easily than I can define the process? Think about that for a moment. If I can clearly describe the outcome I want, but I'm not entirely sure what steps are required to get there, an agent might be a good fit. For example, you may want the agent to find the most important developments in AI this week and explain why they matter. That's a clear objective. But there are many possible ways to achieve it. In that case, an agent can help. Now, compare that with when an article is published, send a Slack notification. The process is already known. The workflow is already defined. An agent doesn't add much value there. As organizations begin exploring AgentOS, they'll often discover dozens of potential use cases. The challenge isn't in finding opportunities. The challenge is identifying the opportunities where agentic reasoning actually creates value. Because the best agent projects aren't the ones that replace simple workflows. They're the ones that augment human knowledge work. #### Key takeaways - Connect **What Makes a Good Agent Problem?** back to your stack configuration before moving to the next module. - Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment. - Re-read the delivery versus management boundary for anything you changed in the entry model. ### Lesson 05 — What Makes a Bad Agent Problem? #### Video details #### At a glance - **Title:** What Makes a Bad Agent Problem - **Duration:** 3m 50s - **Media link:** https://cdn.jwplayer.com/previews/uh8O9q0G - **Publish date (unix):** 1780928317 #### Streaming renditions - application/vnd.apple.mpegurl - audio/mp4 · AAC Audio · 113650 kbps - video/mp4 · 180p · 180p · 173705 kbps - video/mp4 · 270p · 270p · 212452 kbps - video/mp4 · 360p · 360p · 246914 kbps - video/mp4 · 406p · 406p · 263839 kbps - video/mp4 · 540p · 540p · 334460 kbps - video/mp4 · 720p · 720p · 435799 kbps - video/mp4 · 1080p · 1080p · 697384 kbps #### Timed text tracks (delivery) - **thumbnails:** `https://cdn.jwplayer.com/strips/uh8O9q0G-120.vtt` #### Video transcript So, we talked about the kinds of problems that are well-suited for agents, research, analysis, decision support, content creation. Now let's talk about the other side of the equation, because one of the fastest ways to create a disappointing AI project is to use an agent where a simpler solution would have worked better. There's a tendency in every new technology wave to treat the new thing as the answer to every problem. We've seen this with cloud. We've seen it with mobile. We've seen it with machine learning. Now we're seeing it with agents. The reality is that many business problems are already solved quite effectively through automation. Let's start with highly predictable processes. Imagine a workflow where an entry gets published and a Slack message gets sent. There's nothing ambiguous about that. There's no reasoning required. There's no judgment involved. The process is already known. In that situation and situations like this, traditional automation is usually the better choice. It's simpler, it's more predictable, and it's easier to maintain. Next are compliance-heavy workflows. Whenever a process involves a strict regulatory requirement, legal obligation, or highly controlled business rules, organizations often want a consistent and repeatable behavior. That's not because agents are incapable of helping. It's because variability may introduce risk. In those situations, deterministic workflows often remain the preferred solution. Another category is mission-critical operational processes. For example, payment processing, financial transactions, infrastructure provisioning, security operations. In these cases, organizations typically want systems that behave exactly the same way every single time. The objective isn't flexibility. The objective is reliability. And finally, there are simple repetitive tasks. If a workflow consists of a trigger and a handful of predefined actions, adding an agent may actually make the solution more complicated. Remember, agents introduce reasoning. Reasoning introduces variability. Variability introduces oversight. And oversight introduces cost. That doesn't mean that agents are bad. It simply means they should be used where reasoning creates value. A useful question to ask yourself is this. If I already know every step in the process, why am I using an agent? Think about that for a moment. If the workflow can be fully described as a sequence of actions, a traditional automation may be exactly what you need. Agents become valuable when you know the destination but need the flexibility in how you get there. One of the most successful patterns we're seeing emerge is actually a combination of both approaches. The agent performs the reasoning. The automation performs the predictable execution. The agent identifies the opportunity. The automation handles the operational work. Together, they create systems that are both intelligent and dependable. And that's often where the biggest business value appears. #### Key takeaways - Connect **What Makes a Bad Agent Problem?** back to your stack configuration before moving to the next module. - Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment. - Re-read the delivery versus management boundary for anything you changed in the entry model. ### Lesson 06 — Designing an Agent Workflow #### Video details #### At a glance - **Title:** Designing an Agent Workflow - **Duration:** 4m 7s - **Media link:** https://cdn.jwplayer.com/previews/xDVXljW9 - **Publish date (unix):** 1780928273 #### Streaming renditions - application/vnd.apple.mpegurl - audio/mp4 · AAC Audio · 113696 kbps - video/mp4 · 180p · 180p · 176270 kbps - video/mp4 · 270p · 270p · 213403 kbps - video/mp4 · 360p · 360p · 246345 kbps - video/mp4 · 406p · 406p · 265358 kbps - video/mp4 · 540p · 540p · 339218 kbps - video/mp4 · 720p · 720p · 433102 kbps - video/mp4 · 1080p · 1080p · 733518 kbps #### Timed text tracks (delivery) - **thumbnails:** `https://cdn.jwplayer.com/strips/xDVXljW9-120.vtt` #### Video transcript At this point, we've explored what agents are, how they differ from automations, what kinds of problems they're good at solving, and where they may not be the right solution. Now let's bring all that together into a practical framework you can use before building any agent. One of the biggest problems that people have when it comes to working with agents is starting with the technology. They open the platform, they start adding tools, they connect integrations, and they try to figure out what the agent should do. But successful agent design usually works in the opposite direction. You start with the problem, then you design the solution. Only then do you build it. To help with that process, I like to use a simple four-part framework. Goal, inputs, tools, outputs. Let's walk through each one. First, the goal. This is the most important part. What are you actually trying to accomplish? Not what tool do you want to use, not what integration you want to connect with. What's the outcome? For our news intelligence agent example, the goal is simple. Identify important AI news stories and communicate the findings to the organization. That's the objective. Everything else exists to support that objective. Next, we have inputs. Inputs are the information the agent needs in order to do its work. What data will it consume? What information will it analyze? What context does it require? Using the same example, the inputs are news articles, search results, and information discovered through web search. Without inputs, the agent has nothing to reason about. Third, we have tools. Tools determine what actions the agent can perform. Notice, the tools come third, not first. Too often people start by asking, what tools can I connect? Instead, ask, what tools does the objective require? In our example, the agent needs a web search capability to discover information, it needs a content stack capability to create an entry, and it needs a Slack capability to communicate results. Those tools support the goal, they don't define the goal. Finally, we have outputs. What should success look like? What is the deliverable? What should exist when the agent finishes its work? For that news intelligence agent, success means a set of content entries exist inside of content stack, a summary has been delivered to the appropriate Slack channel, the information is available for the organization to use. The output should be crystal clear before the first line of instructions is ever written. And that's where many agent projects struggle. People spend hours thinking about triggers, tools, and models, but they haven't clearly defined what success looks like. If the output is unclear, the instructions become unclear. If the instructions become unclear, the results are unpredictable and inconsistent. So before you build an agent, pause and walk through this framework. What's the goal? What inputs are required? What tools are needed? What outputs define success? If you can answer those four questions, you're already most of the way towards a successful implementation. Because good agent design rarely starts inside the software. It starts with understanding the workflow you're trying to improve. #### Key takeaways - Connect **Designing an Agent Workflow** back to your stack configuration before moving to the next module. - Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment. - Re-read the delivery versus management boundary for anything you changed in the entry model. ### Lesson 07 — How Agent OS Components Work Together #### Video details #### At a glance - **Title:** How AgentOS Components Work Together - **Duration:** 2m 5s - **Media link:** https://cdn.jwplayer.com/previews/FvInGbqu - **Publish date (unix):** 1780928285 #### Streaming renditions - application/vnd.apple.mpegurl - audio/mp4 · AAC Audio · 114273 kbps - video/mp4 · 180p · 180p · 180963 kbps - video/mp4 · 270p · 270p · 226152 kbps - video/mp4 · 360p · 360p · 274077 kbps - video/mp4 · 406p · 406p · 292664 kbps - video/mp4 · 540p · 540p · 382729 kbps - video/mp4 · 720p · 720p · 509837 kbps - video/mp4 · 1080p · 1080p · 860310 kbps #### Timed text tracks (delivery) - **thumbnails:** `https://cdn.jwplayer.com/strips/FvInGbqu-120.vtt` #### Video transcript Throughout this course, we've explored the foundational concepts behind AgentOS. We've discussed the differences between agents and automations. We've examined triggers, tools, instructions, and models. We've talked about the types of problems agents are well-suited to solve and how AI-powered systems can help people accomplish meaningful work. We've also looked at the major components of AgentOS and the different roles they play. Polaris helps people perform work more efficiently. Agents work towards objectives using tools and instructions available to them. And automations handle predictable, repeatable processes. Each serves a different purpose, and together they create powerful systems that combine human expertise with AI capabilities. At this point, you understand the concepts. The next step is putting them into practice. In the next course, we'll build a complete content enrichment agent from start to finish. We'll create a project, configure triggers, connect tools, write instructions, and build an agent capable of analyzing newly created content, generating teasers, SEO metadata, and tags, while also updating entries in content stack and preparing the content for review. As you work through that project, you'll see every concept we've discussed in this course come together. The trigger tells the agent when to begin. The tools provide access to content and actions. The instructions define the desired outcome. And the model provides the reasoning needed to generate useful results. By the end of the next course, you won't just understand how agents work. You'll have built one yourself. Thanks for joining me, and I hope to see you in the next course. #### Key takeaways - Connect **How Agent OS Components Work Together** back to your stack configuration before moving to the next module. - Capture one concrete artifact (screenshot, Postman call, or code snippet) that proves the step works in your environment. - Re-read the delivery versus management boundary for anything you changed in the entry model. ## Resources & references | Page | Companion Markdown | | --- | --- | | /courses/agentos-foundations/welcome-to-agent-os | /academy/md/courses/agentos-foundations/welcome-to-agent-os.md | | /courses/agentos-foundations/agents-vs-automations | /academy/md/courses/agentos-foundations/agents-vs-automations.md | | /courses/agentos-foundations/the-anatomy-of-an-agent | /academy/md/courses/agentos-foundations/the-anatomy-of-an-agent.md | | /courses/agentos-foundations/what-makes-a-good-agent-problem- | /academy/md/courses/agentos-foundations/what-makes-a-good-agent-problem-.md | | /courses/agentos-foundations/what-makes-a-bad-agent-problem- | /academy/md/courses/agentos-foundations/what-makes-a-bad-agent-problem-.md | | /courses/agentos-foundations/designing-an-agent-workflow | /academy/md/courses/agentos-foundations/designing-an-agent-workflow.md | | /courses/agentos-foundations/how-agent-os-components-work-together | /academy/md/courses/agentos-foundations/how-agent-os-components-work-together.md | ## Supplement for indexing ### Content summary Agent OS Foundations introduces the core concepts behind Contentstack Agent OS and provides the knowledge needed to begin building AI-powered solutions. You'll learn how agents differ from automations, how Polaris fits i… Agent OS Foundations introduces the core concepts behind Contentstack Agent OS and provides the knowledge needed to begin building AI-powered solutions. You'll learn how agents differ from automations, how Polaris fits into the Agent OS ecosystem, and how triggers, tools, instructions, and models work together to create intelligent workflows. Through practical examples and real-world scenarios, you'll explore the types of problems agents are designed to solve, understand when to use agents versus automations, and develop the mental models needed to design effective agentic systems. By the end Learn the core concepts behind Contentstack Agent OS. In this course, you'll explore agents, automations, Polaris, triggers, tools, instructions, and models, while learning how these components work together to create intelligent workflows. By the end of the course, you'll have the foundation needed to build your first agent with Agent OS. ### Retrieval tags - Contentstack Academy - agentos-foundations - Welcome - Agent - Agents - Automations - The - Anatomy - What - Makes - Good - Problem - Bad - Designing ### Indexing notes Chunk at each "### Lesson NN — Title" heading; copy lesson_id and topics from the preceding HTML comment into chunk metadata for RAG filters. Course slug: agentos-foundations. Union of lesson topic tokens: Welcome, Agent, Agents, Automations, The, Anatomy, What, Makes, Good, Problem, Bad, Designing, Workflow, How, Components, Work, Together. Do not embed or retrieve LMS-only quiz items or mastery exam answer keys from this export. ### Asset references | Label | URL | | --- | --- | | Video thumbnail: Welcome to Agent OS | `https://cdn.jwplayer.com/v2/media/q7pHDK0A/poster.jpg?width=720` | | Video thumbnail: Agents vs Automations | `https://cdn.jwplayer.com/v2/media/K1x64ULw/poster.jpg?width=720` | | Video thumbnail: The Anatomy of an Agent | `https://cdn.jwplayer.com/v2/media/SRncMVcH/poster.jpg?width=720` | | Video thumbnail: What Makes a Good Agent Problem? | `https://cdn.jwplayer.com/v2/media/MEOS95j0/poster.jpg?width=720` | | Video thumbnail: What Makes a Bad Agent Problem? | `https://cdn.jwplayer.com/v2/media/uh8O9q0G/poster.jpg?width=720` | | Video thumbnail: Designing an Agent Workflow | `https://cdn.jwplayer.com/v2/media/xDVXljW9/poster.jpg?width=720` | | Video thumbnail: How Agent OS Components Work Together | `https://cdn.jwplayer.com/v2/media/FvInGbqu/poster.jpg?width=720` | ### External links | Label | URL | | --- | --- | | Contentstack Academy home | `https://www.contentstack.com/academy/` | | Training instance setup | `https://www.contentstack.com/academy/training-instance` | | Academy playground (GitHub) | `https://github.com/contentstack/contentstack-academy-playground` | | Contentstack documentation | `https://www.contentstack.com/docs/` |