Generating Images with Foundry Agent Service

When the required output is a new image created from a written brief, the solution needs image generation rather than visual interpretation. This episode explains how Foundry Agent Service can use an image-generation tool when the required model and project configuration are ava…

A creative team is building an application that prepares promotional concepts for community events. A user provides a written brief describing a welcoming outdoor market, colorful produce, reusable shopping bags, and space for a headline. The application needs to produce a new image based on that brief. Which capability should the team configure, and what would prove that it worked?

The phrase new image matters. The requested input is text, and the required output is visual. That points to an image-generation capability.

In Microsoft Foundry, Foundry Agent Service can use an image-generation tool to create visual output from text instructions when the required model and project configuration are available. The tool provides a path from the written visual brief to generated image content. It isn’t enough for the application to use something labeled artificial intelligence. The configured capability has to support the kind of transformation the workload requires.

Compare this with a vision task that examines an existing picture. In that case, the application begins with visual input and might return a textual description of what the image contains. That’s useful when you need to understand an image that already exists. It doesn’t satisfy a request to create a new visual from a written brief.

The difference isn’t just the name of a feature. It’s the direction of the work. Existing image to text is visual understanding. Text to a newly created image is image generation.

There’s another adjacent capability that can cause confusion. A text-generation model can turn a short request into a polished written description. If you ask for an outdoor market scene, it might return a paragraph describing stalls, shoppers, banners, and warm afternoon light.

That response could sound vivid and useful, but it’s still text. If the requirement is an actual visual output, a description of an image isn’t evidence that an image was generated. The output type doesn’t match the requirement.

This distinction reflects the current AI-901 emphasis on generative visual output. You’re not expected merely to recognize that generative AI exists. You need to connect the requirement to a suitable capability and understand what implementation evidence supports the decision.

The objective identifiers used in this course are local course labels for Microsoft’s published skill bullets. They aren’t numeric objective identifiers issued by Microsoft. What matters for this lesson is the assessed ability to reason about creating new visual output with generative models.

A reliable decision begins before anyone invokes a model. First, describe the workload without naming a product. What does the application receive? What must it return?

What constraints affect that result? For the community market application, the input is a textual visual brief. The expected output is a newly generated image. The constraints include the details the image should contain, the space needed for a headline, and responsible-use considerations that apply before the output is used.

Once those needs are clear, map them to a capability. The team needs a compatible image-generation path, not merely a general text endpoint and not an image-analysis path. In Foundry Agent Service, that means the image-generation tool must have the required model and project configuration available.

Configuration, prompting, and execution verification are related, but they’re separate concerns. A well-written prompt can’t supply a capability that hasn’t been configured. Correct configuration can’t rescue a brief that fails to communicate the desired scene. Neither one proves that execution produced the expected kind of output.

Before running generation, define success in observable terms. At the most basic level, the application should return visual output rather than only a textual response or a claim that generation occurred. The produced image should then be compared with the written brief.

Does it depict the requested outdoor market? Are the reusable bags and produce represented? Is the composition suitable for the intended use? These checks are different from asking whether a request completed without an obvious error.

The prompt itself should communicate the visual result the team wants. A request such as create a market image leaves many important decisions unstated. A more useful brief identifies the subject, setting, mood, important objects, and compositional need. The team might ask for a welcoming outdoor community market in daylight, with colorful produce stands, a diverse group of shoppers carrying reusable bags, and uncluttered space near the top for a headline. That’s still ordinary language, but it gives the generation capability a clearer target.

Prompt quality doesn’t mean adding every imaginable adjective. The purpose is to express requirements that matter to the workload. If the headline area is essential for the application’s design, include it.

If the exact color of every basket has no business importance, adding that detail may not improve the decision. A prompt is a visual brief, not proof of success. It describes the requested output, while validation determines what was actually produced.

Now follow the decision through execution. The team confirms that the project has access to the required image-generation model and that the image-generation tool is configured for the application. It provides the textual brief through that path and invokes generation.

After execution, it looks for an actual visual result. If an image is returned, the team compares it with the predicted output. If only prose is returned, the requirement hasn’t been met, even if the prose accurately describes the desired scene.

Suppose the result is an image of an outdoor market with produce stands and shoppers, but there’s no clear space for the headline. The generation capability did produce the correct output type, so the implementation has passed one important test. It hasn’t fully met the application’s goal. The team now has evidence that the generation path works, along with evidence that the output doesn’t yet satisfy the complete brief. A sensible next action is to revise the visual instruction or generation choice and test again, rather than declaring the entire capability broken.

That example shows why a successful request and a successful workload aren’t identical. Technical execution might produce an image while business validation rejects it. Conversely, a failed invocation might reveal a capability or configuration problem before prompt quality can even be judged. Keeping these stages separate makes troubleshooting much clearer. Ask whether the appropriate capability exists, whether it’s configured, whether the prompt expresses the need, whether execution produced visual output, and whether that output satisfies the intended use.

Responsible use belongs in that chain rather than being added after everything else. Image generation shouldn’t be treated as unconstrained content creation. The intended subject, the way the visual will be used, and applicable safety expectations influence the design and review of the workload. In this episode, the important implementation point is that safety and responsible-use constraints are part of deciding what counts as an acceptable result. Producing an image is necessary, but it isn’t the only condition for accepting one.

Consider a second team that starts with a tempting assumption. They already have access to a text-generation endpoint, so they conclude that the same endpoint can always generate images without any additional image-generation capability or configuration. They submit the market brief and receive a polished paragraph. It describes a bright market square, wooden stalls, fresh fruit, and smiling shoppers. Someone says the model clearly understood the request, so image generation must be working.

The response doesn’t support that conclusion. It demonstrates that a model produced text related to the request. It doesn’t demonstrate that the endpoint can create visual output, that an image-generation tool is configured, or that an image was generated. The assumption erased the boundary between text generation and image generation. Understanding the subject of an image request isn’t the same as possessing and invoking the capability that creates the image.

The lowest-complexity useful validation is to inspect the output type and the configured path. Was an image-generation capability selected and made available to the application? Did the invocation use that capability?

Did the observable result include visual output? Those checks distinguish a genuine text-to-image result from a textual description without requiring the team to speculate about what happened internally. If the only artifact is prose, the evidence contradicts the claim that the requirement was satisfied.

The correction isn’t that text and image capabilities can never appear within the same broader application. The correction is narrower and more dependable. Don’t assume that access to text generation automatically provides image generation. Use a compatible image-generation model and tool configuration for the visual workload, then verify the observed output. Capability boundaries and evidence are safer guides than a broad claim about what any artificial intelligence endpoint can do.

After correcting the configuration, the team invokes the image-generation path and receives an image. That changes the evidence. The team can now say that this execution produced visual output.

It still can’t conclude, from that fact alone, that every prompt will generate an acceptable image or that the output is ready for production use. It must compare the visual with the brief and apply the relevant responsible-use and safety review. One successful artifact supports a limited conclusion about that execution, not an unlimited conclusion about the whole system.

Failures can occur at different points, and the observable result helps identify where to look next. If the needed image-generation capability isn’t available or configured, rewriting the prompt won’t establish that missing capability. If the configured tool produces an image that omits a requested compositional detail, the prompt and output comparison become more relevant. If the image matches the visible request but violates a safety expectation for the intended use, technical generation still hasn’t produced an acceptable result.

This is why configuration, prompt quality, and verification shouldn’t be collapsed into one vague idea of making the model work. Each answers a different question. Configuration asks whether the application has an appropriate generation path.

The prompt communicates the requested visual. Invocation asks the configured capability to perform the work. Verification checks what came back and whether it meets the requirement. Responsible-use review applies the constraints that determine whether the output should be accepted or used downstream.

The same reasoning connects to the broader AI-901 decision pattern. Start with the requirement rather than a familiar product name. Classify the workload by its input and desired output. Select a capability that supports that transformation.

Account for relevant constraints. Implement the path, then verify observable behavior. This sequence prevents memorization from replacing technical judgment. A service name by itself doesn’t tell you whether a specific model, tool, or configuration supports the requested workload.

For an unfamiliar scenario, listen for the clues that control the decision. If a design team needs a new banner concept from a written description, the new visual output is the key clue. If an accessibility feature needs text describing an uploaded photograph, the clue points in the other direction, toward understanding existing visual input.

If a copywriting feature needs a paragraph describing a proposed scene, text generation may be enough. Similar subjects don’t make these workloads interchangeable. Their required outputs separate them.

You should also be able to explain why you rejected an alternative. Saying choose image generation because the question asks for an image is a useful beginning, but it leaves out the implementation reasoning. A stronger explanation is that the workload accepts a textual visual brief and requires newly created visual output. Therefore, it needs a compatible image-generation capability and configuration. A text-only response or an analysis of an existing image wouldn’t satisfy the required input-to-output behavior.

Then add the evidence. The implementation is verified when the configured generation path is invoked and observable visual output is produced. That visual must be compared with the requested content and the workload’s constraints before it’s trusted.

This explanation connects the scenario clue, capability choice, rejected alternative, and validation method. It also makes uncertainty visible. If you haven’t inspected the output, you can say that the configuration appears suitable, but you can’t yet say that the execution met the requirement.

Imagine that a multiple-choice scenario describes a creative application, a written visual brief, and a need for a new image. One option analyzes an uploaded photograph. Another returns marketing copy.

A third configures and invokes an image-generation capability, then checks the resulting visual. The third option fits because every part of its input and output behavior matches the workload. Its verification step also provides evidence instead of relying on the absence of an error.

Now imagine that the scenario says the invocation completed, but the application received only a textual description. Completion isn’t enough. Return to the contract established by the requirement.

The expected output was visual, while the observed output was text. That mismatch justifies checking the selected model, tool, project configuration, endpoint path, and invocation mode within the documented implementation. You don’t need to guess which component failed before examining the evidence. You do need to reject the claim that the visual requirement has already been met.

A practical explanation can stay concise without becoming shallow. State what the application receives, what it must produce, which capability performs that transformation, and how you’ll verify the result. For the market application, that sounds like this: the input is a written scene description, the required output is a newly generated market image, so the application needs a configured image-generation path. After invocation, the team must observe an image and compare it with the brief and applicable constraints.

That reasoning also keeps the role of the prompt in perspective. The prompt matters because it carries the visual requirements into generation. It doesn’t choose or configure the capability by itself, and it doesn’t certify the returned image as acceptable.

Likewise, a correct capability doesn’t excuse an unclear brief. The whole implementation works as a chain. A weakness at one point changes what the result can prove.

For the creative team, the defensible choice is now clear. Configure a compatible image-generation capability in the Foundry project, provide the textual visual brief through that path, invoke generation, and inspect the returned artifact. Confirm that visual output exists before judging its contents. Then compare that visual with the requested scene and constraints. If the evidence doesn’t match the prediction, correct the relevant part of the implementation and verify again rather than broadening the conclusion beyond what was observed.

Generating an image is a complete implementation decision, not just a well-written request. Begin with the input and required output, then choose a capability that can turn the textual visual brief into a new visual result. Keep configuration, prompting, invocation, and verification distinct, because success at one stage doesn’t prove success at the others.

Most importantly, don’t assume that a text-generation endpoint automatically supplies image generation. The evidence must show that a compatible image-generation path was used and that visual output was actually produced. Once it is, compare the result with the brief and the workload’s responsible-use constraints. That’s what turns a plausible configuration into a defensible Foundry implementation.

Before moving on, ask yourself: What configuration, prompt, invocation, and verification steps must all succeed before an image-generation feature is complete? Use the companion episode reference for text-to-image input, image-generation tool, model and project configuration, output handling, and verification. This lesson was produced by Bare Metal Cyber dot com.

Generating Images with Foundry Agent Service
Broadcast by