Designing a Single-Agent Solution with Foundry Agent Service
A team wants an assistant for its internal support staff. The assistant should follow the team’s operating instructions, respond through an appropriate model, and use approved tools when a request requires more than a text-only answer. The team doesn’t want to build and operate a custom runtime. It wants a managed service and a clear way to observe whether the resulting assistant behaves as intended.
That sounds like a reasonable single-agent scenario, but the word agent can make the design seem more mysterious than it is. The useful starting point is to identify the parts and the responsibility each one carries. A model produces responses.
Instructions describe the behavior expected from the agent. Tools can give the agent supported capabilities beyond producing an answer directly from the model. The agent brings those elements together around a particular job.
Microsoft Foundry Agent Service is a managed platform for building, deploying, and scaling AI agents. Managed doesn’t mean that every design decision disappears. It means the platform provides a supported environment for the agent lifecycle, including capabilities related to identity, networking, observability, and safety controls. You still need to decide what the agent should do, which implementation path fits, and what evidence will show that it works.
In a single-agent architecture, one agent is responsible for the defined interaction. That doesn’t imply that the model can do everything by itself. It means you haven’t divided the work among several cooperating agents. The single agent can still have instructions and tools. Its behavior should be judged against the job assigned to it, not against the vague expectation that an agent must be generally intelligent or autonomous.
This architecture sits beyond a bare model deployment. Deploying a model gives an application access to model capabilities, but that deployment alone doesn’t express the complete agent design. The agent has an operational role defined by instructions and, when needed, tools. Foundry Agent Service also provides a managed setting around that design. Calling the agent a renamed model deployment would erase the distinctions that matter when you choose, test, and operate the solution.
There’s also an important choice within the agent approach. Foundry supports prompt agents, which are primarily defined through instructions, models, and tools. It also supports hosted agents for situations that require custom code and greater runtime control.
Those paths both concern agents, but they answer different implementation needs. You don’t choose between them by asking which name sounds more advanced. You choose by identifying what the workload actually requires.
Return to the internal support assistant. Its input will be a staff member’s request. Its desired output will be a response that follows the support team’s instructions and, where appropriate, uses an approved tool.
The stated constraint is equally important. The team doesn’t want custom runtime code. Those clues point toward a prompt agent because the required design is centered on instructions, a model, and available tools rather than a custom coded runtime.
Notice what hasn’t justified a hosted agent. The assistant may have an important business purpose, and it may need careful controls, but importance by itself isn’t a requirement for custom code. Greater runtime control is relevant when the scenario actually calls for it. Selecting a hosted agent merely because it sounds more powerful would add an implementation choice that the requirement didn’t ask for.
A repeatable decision starts with four questions. What goes into the solution? What result should come out?
Which capability is needed between those two points? What constraints limit the acceptable implementation? These questions keep a product label from becoming a substitute for reasoning.
For the support assistant, the incoming item is a user request. The expected result isn’t just fluent text. It’s a response shaped by the support instructions and consistent with the intended use of tools.
The required capability is therefore more than access to a model. The design needs an agent that coordinates the model, its instructions, and any approved tools. The constraint against custom runtime code then helps select the prompt-agent path.
The next question is what success would look like. Define that before treating the implementation as correct. A successful test might show that the agent follows the intended role, responds appropriately to an ordinary support question, and uses a configured tool only in a case where that tool is relevant. It should also show what happens when the request falls outside the intended role. These observations are more useful than saying that the agent produced an answer and therefore works.
You also need to consider the surrounding operational requirements. Foundry Agent Service includes capabilities for identity, networking, observability, and safety controls. The existence of those capabilities doesn’t choose the correct settings for the team. It tells you that these concerns belong in the implementation decision rather than being treated as unrelated work after the agent has been built.
Suppose the support tool reaches information that shouldn’t be available to every user. A fluent answer can’t prove that access was appropriate. The implementation must still fit the team’s identity and networking requirements. Likewise, an agent that gives a plausible response hasn’t demonstrated that its behavior can be observed adequately or that the applicable safety controls have been considered. The output is one piece of evidence, not the whole decision.
This gives the team a practical chain. Begin with the requirement. Identify the input and expected output.
Match them to the agent capability. Choose prompt agent or hosted agent according to the need for custom code and runtime control. Check the relevant operational constraints. Then test the observed behavior against the original requirement.
If the team follows that chain, the prompt-agent choice is defensible. It isn’t correct merely because the scenario used the word instructions. It fits because the job can be described through instructions, a model, and tools, while the team has specifically ruled out custom runtime code. The selected capability and the implementation constraint point in the same direction.
Now imagine the first test produces a polished answer to a support request. It would be tempting to call the test successful immediately. But polished language doesn’t establish that the agent followed its assigned instructions, used the right capability, or respected the intended boundary. A model can produce plausible text even when the larger solution isn’t meeting the workload.
Validation begins by comparing the observation with an expected input and output contract. For an ordinary question that needs no tool, the expectation may be an answer that stays within the defined support role. For a request that requires an approved tool, the expected behavior should include appropriate use of that tool. If the observed response doesn’t match, the discrepancy tells you where further investigation is needed.
The cause shouldn’t be guessed from one disappointing response. Revisit the design systematically. Is the selected model or service capable of supporting the intended behavior? Do the instructions express the required role clearly enough?
Is the relevant tool part of the agent design? Does the implementation path fit the need for runtime control? Are the service configuration and operational constraints consistent with what the team intended? The accepted evidence comes from behavior observed against those requirements, not from confidence in the product name.
Consider a failure in which the assistant answers a tool-dependent question with convincing but unsupported text. If the team believes an agent is merely a renamed model deployment, that result may look acceptable. The model returned an answer, so the system appears to be functioning. The mistaken mental model hides the actual failure because it never asks whether the agent’s tool-enabled behavior occurred.
A low-complexity validation can distinguish those interpretations. Test one request that can be handled by the instructed model behavior and another controlled request that requires the configured tool. Compare both results with the expected behavior. If the first request succeeds but the second never produces the intended tool-supported result, you haven’t proved that the complete agent design works. You’ve only observed that the model can produce a response.
The next action should follow the evidence. Check whether the tool is present in the design and whether the selected agent path supports the intended implementation. Revisit the instructions and configuration. Then run the controlled comparison again. A corrected result provides better evidence, though it still doesn’t prove that every possible request, operational condition, or safety concern has been covered.
That final qualification matters. Testing can support a particular conclusion, but it shouldn’t be stretched into a broader guarantee. If you tested two representative requests, you can explain what happened for those requests and whether they matched the expected behavior. You can’t honestly conclude from them that the agent will handle every future input correctly. Remaining uncertainty should be recorded rather than hidden behind a successful demonstration.
The same reasoning exposes why the renamed-deployment misconception is risky. It collapses several different questions into one. Does a model endpoint respond? Does the agent follow the required instructions?
Can it use the intended tools? Does the implementation path match the need for runtime control? Can the team observe the behavior and apply the needed identity, networking, and safety controls? These aren’t interchangeable questions.
A model deployment may be part of the agent design, but a part doesn’t define the whole architecture. If you only verify that the model returns text, you’re verifying the model interaction, not every responsibility assigned to the agent. The safer rule is to identify the documented capability boundary, connect it to the workload, and validate the resulting behavior.
This decision pattern also connects with intentional conversation handling. An application can receive a response and display it, yet still fail to manage the broader interaction in the way the workload requires. In the same way, an agent can produce an attractive first response while failing another part of its assigned role. Observable behavior has to be compared with the intended interaction, not judged by fluency alone.
For AI-901, it helps to keep the chain compact. Begin by stating what the workload must accomplish. Classify the needed capability.
Select the implementation that fits the constraints. Verify the result with observable evidence. This prevents you from memorizing that every assistant should be a prompt agent or that every complex-sounding workload requires a hosted agent.
Imagine that a different team needs an agent but explicitly requires custom code and greater control over its runtime. That requirement changes the selection. A prompt agent is primarily defined through instructions, models, and tools, while the documented purpose of the hosted-agent path includes scenarios needing custom code and greater runtime control. Hosted agent is therefore the better architectural candidate for that requirement.
The word candidate is deliberate. Choosing the right category is not the same as proving that the finished implementation works. The team must still define expected inputs and outputs, account for its constraints, and observe the result. Architecture selection tells you which path is appropriate to pursue. Validation tells you whether the implementation on that path satisfies the workload you actually have.
Now remove the custom-code requirement. The team only needs managed agent behavior defined through instructions, a model, and tools. Continuing to choose hosted agent simply because it offers more control would no longer follow the stated need. The prompt-agent path is the lower-complexity fit supported by the scenario. The decision changes because the requirement changes, not because one product category has become universally better than another.
Operational controls belong in this explanation without turning the decision into specialist administration. If the workload has identity, networking, observability, or safety requirements, acknowledge them as constraints and verification concerns. You don’t need to invent detailed settings to recognize that a design must account for them. At a fundamentals level, the essential skill is knowing that a successful text response doesn’t make those responsibilities disappear.
You should be able to explain the support-team decision in one connected statement. The team needs a managed agent that follows instructions, uses a model and approved tools, and doesn’t require custom runtime code. A prompt agent fits those clues better than a hosted agent. The team should test ordinary and tool-dependent requests, compare the responses with the expected behavior, and review the relevant operational evidence before accepting the implementation.
That explanation names the scenario clue, the selected capability, the rejected alternative, and the validation evidence. It’s stronger than saying prompt agent because the question mentioned instructions. It would also transfer to an unfamiliar situation because the reasoning isn’t tied to the wording of one example.
When an observed result conflicts with your prediction, treat the conflict as useful evidence. Perhaps the capability was misunderstood. Perhaps the instructions, tools, or configuration don’t represent the intended design. Perhaps the team chose a prompt agent for a requirement that genuinely depends on custom code and runtime control. Revising the decision after observing that mismatch is better engineering than defending the first answer.
A single agent is therefore not a promise of simplicity in every operational detail. It’s an architectural boundary around one agent’s responsibility. Within that boundary, you still have a model, instructions, possible tools, an implementation path, and managed platform concerns. Keeping those parts visible makes both selection and troubleshooting more precise.
For the original team, the architecture can now be stated without exaggeration. Foundry Agent Service supplies the managed agent platform. The prompt-agent path fits the absence of custom runtime code and the reliance on instructions, a model, and tools. Controlled tests provide evidence about whether the resulting behavior matches the support workload. If those observations don’t match, the team revisits the assumptions and configuration instead of treating any plausible model response as success.
The practical distinction is now clear. A single agent brings a model together with instructions and, when the workload needs them, tools. It isn’t merely a new label for a model deployment.
In Foundry, a prompt agent fits a managed design centered on those elements, while a hosted agent is the path to consider when custom code and greater runtime control are actual requirements. Whichever path you choose, the product name doesn’t prove the result. Define the expected input and output, account for operational constraints, and compare observed behavior with the job the agent was meant to perform. That requirement-to-evidence chain turns an architectural label into a decision you can explain and verify.
Before moving on, ask yourself: Which responsibilities belong to the model, instructions, tools, agent, and managed platform? Use the companion episode reference for agent components, prompt agents, hosted agents, managed service responsibilities, and workload fit. This lesson was produced by Bare Metal Cyber dot com.