Agentic Applications With Amazon Bedrock: A Practical Workshop for Structured AI Systems
Bridge the gap between LLM experimentation and production software with this step-by-step guide to building structured, tool-calling AI agents on AWS.
I'm a versatile tech professional working at the intersection of Machine Learning, Data Engineering, and Full Stack Development. With hands-on experience in distributed systems, pipelines, and scalable applications, I translate complex data into real-world impact.
Introduction
The conversation around generative AI is rapidly moving from simple prompting to agentic systems. Organizations are no longer asking only how to generate text. They are asking how large language models can reason over context, call tools, produce structured outputs, and participate in end-to-end workflows.
That is where agentic application design becomes important.
An agentic system is not just a model responding with language. It is a coordinated interaction between non-deterministic reasoning and deterministic execution. The model interprets the objective, decides when to ask for action, and works within a structured environment that the application defines.
This workshop was created to help learners understand that transition in a clear, practical way.
Repository reference:
- GitHub repository:
https://github.com/TuWienProjects/aws-cloud-workshop3-bedrock
Direct documentation path inside the repository:
- Agentic track:
docs/workshops/workshop-03-bedrock/agentic/README.md
What Is an Agentic Application?
An agentic application combines:
A large language model for reasoning, interpretation, and language generation
A controlled application environment for tools, rules, and orchestration
Deterministic software components for execution, validation, and system boundaries
This distinction is important because many teams misuse the word “agent” to describe any chatbot. In practice, an agentic application has a richer interaction model. It can reason about steps, request tool use, consume results, and continue progressing toward a goal.
That does not mean every system should be fully autonomous. In fact, strong agentic design is usually about disciplined orchestration, not uncontrolled freedom.
Why This Workshop Matters
Many developers understand how to call a foundation model, but fewer understand:
How messages and content blocks are structured internally
How tools are described so models can use them correctly
Why schema quality affects agent reliability
How structured output improves downstream automation
How to move from notebook experiments to reusable demos and interfaces
This workshop closes that gap by teaching agentic systems as an engineering discipline rather than a trend.
Who Should Read This Workshop
This workshop is especially useful for:
Developers moving from prompt-based experiments to tool-enabled AI systems
Engineers building assistants, internal copilots, or automation workflows
Students studying modern AI application architecture
Technical content creators who want accurate, practical agentic examples
It is best approached after completing a foundational Bedrock workshop or after gaining basic familiarity with Bedrock runtime APIs.
What Learners Will Gain
By the end of the agentic workshop, learners should be able to:
Explain what an agent is in technical and operational terms
Understand the agent loop as a system design pattern
Interpret how messages, roles, and content blocks drive model interaction
Design tool schemas that improve execution reliability
Use decorators and type annotations to generate better tool definitions
Apply structured output patterns for dependable extraction workflows
Package agent logic into reusable demos, command-line interfaces, and simple web applications
Workshop Structure
The agentic track is organized as a progressive learning sequence. Each lab introduces a layer of abstraction that supports the next one.
Lab-by-Lab Breakdown of the Agentic Track
Lab A-1: Agents and Agentic Applications
This lab introduces the conceptual foundation of the track.
Learners explore:
What an AI agent is
How tools enable interaction with the environment
What the agent loop looks like in practice
Why agentic applications combine deterministic and non-deterministic system components
This is the right starting point because it replaces vague industry language with a concrete system model.
Lab A-2: Messages and Content Blocks
Once the agent concept is clear, learners study the structure of agentic interactions.
This lab focuses on:
Roles such as user, assistant, and system
Messages as conversational units
Content block types such as text, tool use, and tool results
How conversation state is preserved across turns
This is one of the most important labs in the series because many developers rely on frameworks without ever understanding the underlying message structure.
Why This Matters
If you do not understand the message model, you cannot debug tool behavior effectively, evaluate agent mistakes properly, or design clean orchestration logic.
Lab A-3: Tool Schema
This lab moves from interaction structure to tool definition quality.
Learners examine:
Why JSON schema matters in agentic systems
How parameter definitions influence model behavior
Why vague or poorly structured schemas reduce reliability
How schema precision improves tool selection and input quality
For production-minded teams, this lab is especially valuable because tool quality is often the difference between a reliable assistant and an unreliable one.
Lab A-4: Tool Function Decorators
This lab builds on schema concepts by showing how Python function signatures and annotations become tool definitions through the Strands Agents SDK.
Learners see how to:
Define tool parameters cleanly
Use annotations and descriptions intentionally
Improve model understanding of function purpose and input expectations
Build tools that are easier to reuse and reason about
This is where agent design starts to feel like software craftsmanship rather than framework assembly.
Lab A-5: Structured Output
Structured output is one of the most valuable patterns in practical LLM engineering.
Instead of accepting raw free-form text for every task, learners explore how to define expected output shapes using Pydantic models. This helps with:
Information extraction
Workflow automation
Validation
Downstream integration with business systems
Reducing ambiguity in model output handling
This lab is essential for developers building systems that must produce predictable data rather than only conversational prose.
Lab A-6: Building Agentic Demo Apps
This lab turns architectural understanding into application structure.
Learners move from isolated examples to reusable delivery patterns such as:
One-off demo scripts
CLI interfaces
CLI chat interfaces
Streamlit-based demos
Separation of agent logic from presentation logic
This is a highly practical lab because many projects fail not at the model layer, but at the integration and presentation layer. Demonstrating agentic behavior clearly is part of building it well.
Core Engineering Ideas the Workshop Teaches
Beyond individual labs, the workshop reinforces several core engineering principles.
1. Agents Need Boundaries
An agent is more useful when its environment is clearly defined. Tools, prompts, schemas, and output expectations provide those boundaries.
2. Tooling Quality Shapes Agent Quality
If tool descriptions, schemas, or parameter definitions are weak, agent performance degrades. Good tool design is not optional.
3. Structured Output Is a Reliability Pattern
Free-form language is powerful, but structured output is what enables automation, validation, and maintainable downstream integration.
4. Demo Architecture Matters
A strong prototype separates core logic from interface concerns. This makes future evolution toward APIs, services, or production front ends much easier.
How This Workshop Connects to Amazon Bedrock
Amazon Bedrock provides the managed model access layer, while agentic frameworks and application logic build on top of that foundation.
In that sense, this workshop helps learners understand the next architectural layer above direct model invocation:
Bedrock supplies the model access and managed platform
The application supplies tools, state, schemas, and orchestration
The agent loop coordinates reasoning and execution
That is the practical reality of modern agentic application development.
Recommended Reader Journey
The best progression for most learners is:
Complete the foundational Bedrock workshop first
Study agents and the agent loop
Learn messages and tool invocation mechanics
Improve precision through schemas and decorators
Add structured outputs for reliability
Package the result into demos and reusable interfaces
This sequence helps learners build conceptual clarity before tackling more advanced design problems.
Why This Workshop Is Useful for Teams
For teams, this workshop is not just educational material. It can also serve as:
Internal onboarding material for AI platform adoption
A shared vocabulary for agentic design discussions
A reference path for hackathons and proof-of-concept projects
Supporting material for technical blog posts and learning series
That is especially valuable because many teams are experimenting with agents without yet having a consistent internal model for how agentic systems should be designed.
Final Thoughts
Agentic systems are not magic. They are structured software systems that place a large language model inside a controlled loop of context, tools, and execution. When taught clearly, they become far less mysterious and far more useful.
This workshop provides that clarity through a practical progression from concepts to implementation patterns.
If you want to understand how modern AI applications move from simple text generation to tool-enabled reasoning and structured workflows, this agentic workshop is an excellent place to begin.
For the full workshop documentation and code references, visit:
https://github.com/TuWienProjects/aws-cloud-workshop3-bedrock
