Scaling generative AI in the cloud: Enterprise use cases for driving secure innovation 

Generative AI was made for the cloud. Only when you bring AI and the cloud together can you unlock the full potential of AI for business. For organizations looking to level up their generative AI capabilities, the cloud provides the flexibility, scalability and tools needed to accelerate AI innovation. Migration clears the roadblocks that inhibit AI adoption, making it faster and easier to not only adopt AI, but to move from experimentation to driving real business value.

Whether you are interested in tapping into real-time insights, delivering hyper-personalized customer experiences, optimizing supply chains with predictive analytics, or streamlining strategic decision-making, AI is reshaping how companies operate. Organizations relying on legacy or on-premises infrastructure are approaching an inflection point. Migration is not just a technical upgrade, it is a business imperative for realizing generative AI at scale. Without the flexibility the cloud provides, companies face higher costs, slower innovation cycles, and limited access to the data that AI models need to deliver meaningful results. 

Deploy trusted AI quickly with Azure AI services.

For IT and digital transformation leaders, choosing the right cloud platform is key to successfully deploying and managing AI. With best-in-class infrastructure, high-performance compute capabilities, enterprise-grade security, and advanced data integration tools, Azure offers a comprehensive cloud ecosystem that forward-thinking businesses can count on when bringing generative AI initiatives to bear. 

In our technical guide, “Accelerating Generative AI Innovation with Cloud Migration” we outline how IT and digital transformation leaders can tap into the power and flexibility of Azure to unlock the full potential of generative AI. Let us explore a few real-world business scenarios where generative AI in the cloud is driving tangible impact, helping companies move faster, innovate, and activate new ways of working.

Use case 1: Driving smarter, more adaptive AI solutions with real-time data

One of the biggest challenges in AI adoption? Disconnected or outdated data. Ensuring that AI models have access to the most current and relevant data is where Retrieval-augmented generation (RAG) shines. RAG makes generative AI more accurate and reliable by pulling in real-time, trusted data, reducing the chance of errors and hallucinations. 

How does deploying RAG impact businesses? 

Unlike traditional AI models that rely on historical data, RAG-powered AI is dynamic, staying up to date by pulling in the latest information from sources like SQL databases, APIs, and internal documents. This makes it more accurate in fast-changing environments. RAG models help teams: 

Automate live data retrieval, improving efficiency by reducing the need for manual updates. 

Make smarter, more informed decisions by granting access to the latest domain specific information. 

Boost accuracy and speed in interactive apps. 

Lower operational costs by reducing the need for human intervention. 

Tap into proprietary data to create differentiated outcomes and competitive advantages. 

Companies are turning to RAG models to generate more accurate, up-to-date insights by pulling in live data. This is especially valuable in fast-moving industries like finance, healthcare, and retail, where decisions rely on the latest market trends, access to sensitive data, regulatory updates, and personalized customer interactions. 

The Azure advantage:

Cloud-based RAG apps help businesses move beyond static AI by enabling more adaptive, intelligent solutions. When RAG runs in the cloud, enterprises can benefit from reduced latency, high-speed data transfers, built-in security controls, and simplified data governance. 

Azure’s cloud services, including Azure AI Search, Azure OpenAI Service, and Azure Machine Learning, provide the necessary tools to support responsive and secure RAG applications. Together, these services help businesses stay responsive in rapidly changing environments so they are ready for whatever comes next. 

Use case 2: Embedding generative AI into enterprise workflows

Enterprise systems like enterprise resource planning (ERP) software, customer relationship management (CRM), and content management platforms are the backbone of daily operations and crucial to the success of an organization. However, they often rely on repetitive tasks and manual oversight. By integrating generative AI directly into these workflows, businesses can streamline tasks, unlock faster insights, and deliver more personalized, contextually relevant recommendations, all within the existing systems that teams are already using.

What is the business impact of embedding generative AI into enterprise application workflows? 

With AI built into core business applications, teams can work smarter and faster. With embedded generative AI in enterprise apps, industry leaders can: 

Optimize their operations by analyzing supply chain data on the fly, flagging anomalies and recommending actionable insights and proactive adjustments. 

Enrich customer experiences with personalized recommendations and faster response times. 

Automate routine tasks like data entry, report generation, and content management to reduce manual effort and expedite workflows. 

For organizations running on-premises ERP and CRM systems, the ability to integrate AI presents a compelling reason to move to the cloud.

The Azure advantage:

With Azure, companies can bring GenAI into everyday business operations without disrupting them, gaining scalable compute power, secure data access, and modernization while maintaining operational continuity. Migrating these systems to the cloud also simplifies AI integration by eliminating silos and enabling secure, real-time access to business-critical data. Cloud migration lays the foundation for continuous innovation, allowing teams to quickly deploy updates, integrate new AI capabilities, and scale across the enterprise without disruption. 

Azure services like Azure OpenAI Service, Azure Logic Apps, and Azure API Management facilitate seamless integration, amplifying ERP and CRM systems with minimal disruption. 

Microsoft’s collaborations with platforms like SAP showcase how cloud-powered AI delivers current intelligence, streamlined operations, and advanced security—capabilities that are difficult to achieve with on-premises infrastructure. 

When generative AI is embedded into core applications, it goes beyond supporting operations. It transforms them.

Use case 3: Generative search for contextually aware responses

As enterprise data continues to grow, finding the right information at the right time has become a major challenge. Generative search transforms how organizations access and use information. With generative search, employees are empowered to make smarter decisions faster. As data volume grows, generative search helps cut through the noise by combining hybrid search with advanced AI models to deliver context-aware, tailored responses based on real-time data.

How can businesses use generative search to achieve real impact? 

With generative search, companies are better equipped to put their data to work. This approach is ideal knowledge discovery, customer support, and document retrieval, where the goal is to provide meaningful insights, summaries, or recommendations. With generative search, enterprises can: 

Improve customer support by delivering relevant, real-time responses based on customer data. 

Surface critical insights by quickly navigating unstructured and proprietary data. 

Summarize and extract key information from dense documents in less time. 

Across industries, generative search expands access to critical information, helping businesses move faster and smarter.

The Azure advantage:

Cloud-based generative search leverages the processing power and model options available in cloud environments.

Azure services like Azure AI Search, Azure OpenAI Service, and Azure Machine Learning enable productive integration of generative search into workflows, heightening context-aware search. Azure AI Search combines vector and keyword search to retrieve the most relevant data, while Azure OpenAI Service leverages models like GPT-4 to generate summaries and recommendations.

Azure Machine Learning ensures search outcomes remain precise through fine-tuning, and Azure Cognitive Search builds comprehensive indexes for improved retrieval.

Additional components, such as Azure Functions for dynamic model activation and Azure Monitor for performance tracking, further refine generative search capabilities, empowering organizations to harness AI-driven insights with confidence. 

Use case 4: Smart automation with generative AI agents 

There has been plenty of chatter around agentic AI this year, and for good reason. Unlike traditional chatbots, generative AI agents autonomously perform tasks to achieve specific goals, adapting to user interactions and continuously improving over time without needing explicit programming for every situation.

How can AI agents impact a business’s bottom line? 

By optimizing their actions for the best possible outcomes, AI agents help teams streamline workflows, respond to dynamic needs, and amplify overall effectiveness. With intelligent agents in place, companies can:

Automate repetitive, routine tasks, boosting efficiency and freeing teams to focus on higher-value workflows.

Cut operational costs, thanks to reduced manual effort and increased process efficiency.

Scale effortlessly, handling increased workloads without additional headcount. 

Improve service delivery by enabling consistent and personalized customer experiences. 

As demand rises, they scale effortlessly, enabling businesses to manage higher workloads without additional resources. This adaptability is especially valuable in industries with rapidly fluctuating customer demands, including e-commerce, financial services, manufacturing, communications, professional services, and healthcare.

The Azure advantage:

Cloud-based generative AI enables agents to access and process complex, distributed data sources in real time, sharpening their adaptability and accuracy. Microsoft Azure provides a comprehensive suite of tools to deploy and manage generative AI agents successfully: 

Azure AI Foundry Agent Service simplifies the enablement of agents capable of automating complex business processes from development to deployment. 

Azure OpenAI Service powers content generation and data analysis, while Azure Machine Learning enables fine-tuning and predictive analytics. 

Azure Cognitive Services polishes natural language understanding and Azure Databricks facilitates scalable AI model development.

For capable deployment and monitoring, Azure Kubernetes Service (AKS) streamlines containerized workloads, while Azure Monitor tracks live performance, ensuring AI agents operate optimally.

With these capabilities, Azure equips enterprises to harness the full potential of generative AI automation. 

The Azure advantage for generative AI innovation

Migrating to the cloud isn’t just a technical upgrade, it’s a strategic move for companies that want to lead in 2025 and beyond. By partnering with Azure, organizations can seamlessly connect AI models to critical data sources, applications, and workflows, integrating generative AI to drive tangible business outcomes. Azure’s infrastructure gives IT teams the tools to move fast and stay secure at scale. By shifting to a cloud-enabled AI environment, companies are positioning themselves to fully harness the power of AI and thrive in the era of intelligent automation. 

Accelerating Generative AI Innovation with Cloud Migration
Access the whitepaper to learn more about how enterprise can realize the promise of generative AI with Azure. 

Learn more >

The post Scaling generative AI in the cloud: Enterprise use cases for driving secure innovation  appeared first on Microsoft Azure Blog.
Quelle: Azure

Retiring Docker Content Trust

Docker Content Trust (DCT) was introduced 10 years ago as a way to verify the integrity and publisher of container images using The Update Framework (TUF) and the Notary v1 project. However, the upstream Notary codebase is no longer actively maintained and the ecosystem has since moved toward newer tools for image signing and verification. Accordingly, DCT usage has declined significantly in recent years. Today, fewer than 0.05% of Docker Hub image pulls use DCT and Microsoft recently announced the deprecation of DCT support in Azure Container Registry. As a result, Docker is beginning the process of retiring DCT, beginning with Docker Official Images (DOI).

Docker is committed to improving the trust of the container ecosystem and, in the near future, will be implementing a different image signing solution for DOI that is based on modern, widely-used tools to help customers start and stay secure. Watch this blog for more information.

What This Means for You

If you pull Docker Official Images

Starting on August 8th, 2025, the oldest of DOI DCT signing certificates will begin to expire. You may have already started seeing expiry warnings if you use the docker trust commands with DOI. These certificates, once cached by the Docker client, are not subsequently refreshed, making certificate rotation impractical. If you have set the DOCKER_CONTENT_TRUST environment variable to True (DOCKER_CONTENT_TRUST=1), DOI pulls will start to fail. The workaround is to unset the DOCKER_CONTENT_TRUST environment variable. The use of  docker trust inspect will also start to fail and should no longer be used for DOI.

If you publish images on Docker Hub using DCT 

You should start planning to transition to a different image signing and verification solution (like Sigstore or Notation). Docker will be publishing migration guides soon to help you in that effort. Timelines for the complete deprecation of DCT are being finalized and will be published soon.

We appreciate your understanding as we modernize our security infrastructure and align with current best practices for the container ecosystem. Thank you for being part of the Docker community.

Quelle: https://blog.docker.com/feed/

Accelerate modernization and cloud migration

In our recent report, we describe that many enterprises today face a stark reality: despite years of digital transformation efforts, the majority of enterprise workloads—up to 80%—still run on legacy systems. This lag in modernization not only increases operational costs and security risks but also limits the agility needed to compete in a rapidly evolving market. The pressure is on for technology leaders to accelerate the ongoing modernization of legacy applications and to accelerate cloud adoption, but the path forward is often blocked by technical complexity, risk, and resource constraints.  Full Report: Accelerate Modernization with Docker.Enterprises have long been treating modernization as a business imperative. Research shows that 73% of CIOs identify technological disruption as a major risk, and 82% of CEOs believe companies that fail to transform fundamentally risk obsolescence within a decade. Enterprises that further delay modernization risk falling farther behind more agile competitors who are already leveraging cloud-native platforms, DevSecOps practices, and AI or Agentic applications to drive business growth and innovation.

Enterprises challenges for modernization and cloud migration

Transitioning from legacy systems to modern, cloud-native architectures is rarely straightforward. Enterprises face a range of challenges, including:

Complex legacy dependencies: Deeply entrenched systems with multiple layers and dependencies make migration risky and costly.

Security and compliance risks: Moving to the cloud can increase vulnerabilities by up to 46% if not managed correctly.

Developer inefficiencies: Inconsistent environments and manual processes can delay releases, with 69% of developers losing eight or more hours a week to inefficiencies.

Cloud cost overruns: Inefficient resource allocation and lack of governance often lead to higher-than-expected cloud expenses.

Tool fragmentation: Relying on multiple, disconnected tools for modernization increases risk and slows progress.

These challenges have stalled progress for years, but with the right strategy and tools, enterprises can overcome them and unlock the full benefits of modernization and migration.

How Docker accelerates modernization and cloud migration

Docker products can help enterprises modernize legacy applications and migrate to the cloud efficiently, securely, and incrementally.

Docker brings together Docker Desktop, Docker Hub, Docker Build Cloud, Docker Scout, Testcontainers Cloud, and Administration into a seamless, integrated experience. This solution empowers development teams to:

Containerize legacy applications: Simplify the process of packaging and migrating legacy workloads to the cloud.

Automate CI/CD pipelines: Accelerate build, test, and deployment cycles with automated workflows and cloud-based build acceleration.

Embed security and governance: Integrate real-time vulnerability analysis, policy enforcement, and compliance checks throughout the development lifecycle.

Use trusted secure content: Hardened Images ensures every container starts has a signed, distroless base that cuts the attack surface by up to 95 % and comes with built-in SBOMs for effortless audits.

Standardize environments: Ensure consistency across development, testing, and production, reducing configuration drift and late-stage defects.

Implement incremental, low-risk modernization: Rather than requiring a disruptive, multi-year overhaul, Docker enables enterprises to modernize incrementally. 

Increased agility: By modernizing legacy applications and systems, enterprises achieve faster release cycles, rapid product launches, reduced time to market, and seamless scaling in the cloud.

Do not further delay modernization and cloud migrations. Get started with Docker today

Enterprises don’t need to wait for a massive, “big-bang” project — Docker makes it possible to start small, deliver value quickly, and scale ongoing modernization efforts across the organization. By empowering teams with the right tools and a proven approach, Docker enables enterprises to accelerate ongoing application modernization and cloud migrations —unlocking innovation, reducing costs, and securing their competitive edge for the future.

Ready to accelerate your modernization journey?  Learn more about how Docker can help enterprises with modernization and cloud migration – Full Report: Accelerate Modernization with Docker.  

___________Sources:– IBM 1; Gartner 1, 2, 3 – PWC 1, 2– The Palo Alto Networks State of Cloud-Native Security 2024– State of Developer Experience Report 2024___________Tags: #ApplicationModernization #Modernization #CloudMigration #Docker #DockerBusiness #EnterpriseIT #DevSecOps #CloudNative #DigitalTransformation

Quelle: https://blog.docker.com/feed/

Beyond the Chatbot: Event-Driven Agents in Action

Docker recently completed an internal 24-hour hackathon that had a fairly simple goal: create an agent that helps you be more productive.

As I thought about this topic, I recognized I didn’t want to spend more time in a chat interface. Why can’t I create a fully automated agent that doesn’t need a human to trigger the workflow? At the end of the day, agents can be triggered by machine-generated input.

In this post, we’ll build an event-driven application with agentic AI. The event-driven agent we’ll build will respond to GitHub webhooks to determine if a PR should be automatically closed. I’ll walk you through the entire process from planning to coding, including why we’re using the Gemma3 and Qwen3 models, hooking up the GitHub MCP server with the new Docker MCP Gateway, and choosing the Mastra agentic framework.

The problem space

Docker has a lot of repositories used for sample applications, tutorials, and workshops. These are carefully crafted to help students learn various aspects of Docker, such as writing their first Dockerfile, building agentic applications, and more.

Occasionally, we’ll get pull requests from new Docker users that include the new Dockerfile they’ve created or the application updates they’ve made.

Sample pull request in which a user submitted the update they made to their website while completing the tutorial

Although we’re excited they’ve completed the tutorial and want to show off their work, we can’t accept the pull request as it’ll impact the ability for the next person to complete the work.

Recognizing that many of these PRs are from brand new developers, we want to write a nice comment to let them know we can’t accept the PR, yet encourage them to keep learning.

While this doesn’t take a significant amount of time, it does feel like a good candidate for automation. We can respond more timely and help keep PR queues focused on actual improvements to the materials.

The plan to automate

The goal: Use an agent to analyze the PR and detect if it appears to be a “I completed the tutorial” submission, generate a comment, and auto-close the PR. And can we automate the entire process?

Fortunately, GitHub has webhooks that we can receive when a new PR is opened.

As I broke down the task, I identified three tasks that need to be completed:

Analyze the PR – look at the contents of the PR and possibly expand into the contents of the repo (what’s the tutorial actually about?). Determine if the PR should be closed.

Generate a comment – generate a comment indicating the PR is going to be closed, provide encouragement, and thank them for their contribution.

Post the comment and close the PR – do the actual posting of the comment and close the PR.

With this setup, I needed an agentic application architecture that looked like this:

Architecture diagram showing the flow of the app: PR opened in GitHub triggers a webhook that is received by the agentic application and delegates the work to three sub-agents

Building an event-driven application with agentic AI

The first thing I did was pick an agentic framework. I ended up landing on Mastra.ai, a Typescript-based framework that supports multi-agent flows, conditional workflows, and more. I chose it because I’m most comfortable with JavaScript and was intrigued by the features the framework provided.

1. Select the right agent tools

After choosing the framework, I next chose the tools that agents would need. Since this was going to involve analyzing and working with GitHub, I chose the GitHub Official MCP server. 

The newly-released Docker MCP Gateway made it easy for me to plug it into my Compose file. Since the GitHub MCP server has over 70 tools, I decided to filter the exposed tools to include only those I needed to reduce the required context size and increase speed.

services:
mcp-gateway:
image: docker/mcp-gateway:latest
command:
– –transport=sse
– –servers=github-official
– –tools=get_commit,get_pull_request,get_pull_request_diff,get_pull_request_files,get_file_contents,add_issue_comment,get_issue_comments,update_pull_request
use_api_socket: true
ports:
– 8811:8811
secrets:
– mcp_secret
secrets:
mcp_secret:
file: .env

The .env file provided the GitHub Personal Access Token required to access the APIs:

github.personal_access_token=personal_access_token_here

2. Choose and add your AI models

Now, I needed to pick models. Since I had three agents, I could theoretically pick three different models. But, I also wanted to reduce model swapping if possible, yet keep performance as quick as possible. I experimented with a few different approaches, but landed with the following:

PR analyzer – ai/qwen3 – I wanted a model that could do more reasoning and could perform multiple steps to gather the context it needed

Comment generator – ai/gemma3 – the Gemma3 models are great for text generation and run quite quickly

PR executor – ai/qwen3 – I ran a few experiments, and the qwen models did best for the multiple steps needed to post the comment and close the PR

I updated my Compose file with the following configuration to define the models. I gave the Qwen3 model an increased context size to have more space for tool execution, retrieving additional details, etc.:

models:
gemma3:
model: ai/gemma3
qwen3:
model: ai/qwen3:8B-Q4_0
context_size: 131000

3. Write the application

With the models and tools chosen and configured, it was time to write the app itself! I wrote a small Dockerfile and updated the Compose file to connect the models and MCP Gateway using environment variables. I also added Compose Watch config to sync file changes into the container.

services:
app:
build:
context: .
target: dev
ports:
– 4111:4111
environment:
MCP_GATEWAY_URL: http://mcp-gateway:8811/sse
depends_on:
– mcp-gateway
models:
qwen3:
endpoint_var: OPENAI_BASE_URL_ANALYZER
model_var: OPENAI_MODEL_ANALYZER
gemma3:
endpoint_var: OPENAI_BASE_URL_COMMENT
model_var: OPENAI_MODEL_COMMENT
develop:
watch:
– path: ./src
action: sync
target: /usr/local/app/src
– path: ./package-lock.json
action: rebuild

The Mastra framework made it pretty easy to write an agent. The following snippet defines a MCP Client, defines the model connection, and creates the agent with a defined system prompt (which I’ve abbreviated for this blog post). 

You’ll notice the usage of environment variables, which match those being defined in the Compose file. This makes the app super easy to configure.

import { Agent } from "@mastra/core/agent";
import { MCPClient } from "@mastra/mcp";
import { createOpenAI } from "@ai-sdk/openai";
import { Memory } from "@mastra/memory";
import { LibSQLStore } from "@mastra/libsql";

const SYSTEM_PROMPT = `
You are a bot that will analyze a pull request for a repository and determine if it can be auto-closed or not.
…`;

const mcpGateway = new MCPClient({
servers: {
mcpGateway: {
url: new URL(process.env.MCP_GATEWAY_URL || "http://localhost:8811/sse"),
},
},
});

const openai = createOpenAI({
baseURL: process.env.OPENAI_BASE_URL_ANALYZER || "http://localhost:12434/engines/v1",
apiKey: process.env.OPENAI_API_KEY || "not-set",
});

export const prExecutor = new Agent({
name: 'Pull request analyzer,
instructions: SYSTEM_PROMPT,
model: openai(process.env.OPENAI_MODEL_ANALYZER || "ai/qwen3:8B-Q4_0"),
tools: await mcpGateway.getTools(),
memory: new Memory({
storage: new LibSQLStore({
url: "file:/tmp/mastra.db",
}),
}),
});

I was quite impressed with the Mastra Playground, which allows you to interact directly with the agents individually. This makes it easy to test different prompts, messages, and model settings. Once I found a prompt that worked well, I would update my code to use that new prompt.

The Mastra Playground showing ability to directly interact with the “Pull request analyzer” agent, adjust settings, and more.

Once the agents were defined, I was able to define steps and a workflow that connects all of the agents. The following snippet shows the defined workflow and conditional branch that occurs after determining if the PR should be closed:

const prAnalyzerWorkflow = createWorkflow({
id: "prAnalyzerWorkflow",
inputSchema: z.object({
org: z.string().describe("The organization to analyze"),
repo: z.string().describe("The repository to analyze"),
prNumber: z.number().describe("The pull request number to analyze"),
author: z.string().describe("The author of the pull request"),
authorAssociation: z.string().describe("The association of the author with the repository"),
prTitle: z.string().describe("The title of the pull request"),
prDescription: z.string().describe("The description of the pull request"),
}),
outputSchema: z.object({
autoClosed: z.boolean().describe("Whether the PR was auto-closed"),
comment: z.string().describe("Comment to be posted on the PR"),
}),
})
.then(determineAutoClose)
.branch([
[
async ({ inputData }) => inputData.recommendedToClose,
createCommentStep
]
])
.then(prExecuteStep)
.commit();

With the workflow defined, I could now add the webhook support. Since this was a simple hackathon project and I’m not yet planning to actually deploy it (maybe one day!), I used the smee.io service to register a webhook in the repo and then the smee-client to receive the payload, which then forwards the payload to an HTTP endpoint.

The following snippet is a simplified version where I create a small Express app that handles the webhook from the smee-client, extracts data, and then invokes the Mastra workflow.

import express from "express";
import SmeeClient from 'smee-client';
import { mastra } from "./mastra";

const app = express();
app.use(express.json());

app.post("/webhook", async (req, res) => {
const payload = JSON.parse(req.body.payload);

if (!payload.pull_request)
return res.status(400).send("Invalid payload");

if (payload.action !== "opened" && payload.action !== "reopened")
return res.status(200).send("Action not relevant, ignoring");

const repoFullName = payload.pull_request.base.repo.full_name;

const initData = {
prNumber: payload.pull_request.number,
org: repoFullName.split("/")[0],
repo: repoFullName.split("/")[1],
author: payload.pull_request.user.login,
authorAssociation: payload.pull_request.author_association,
prTitle: payload.pull_request.title,
prBody: payload.pull_request.body,
};

res.status(200).send("Webhook received");

const workflow = await mastra.getWorkflow("prAnalyzer").createRunAsync();
const result = await workflow.start({ inputData: initData });
console.log("Result:", JSON.stringify(result));
});

const server = app.listen(3000, () => console.log("Server is running on port 3000"));

const smee = new SmeeClient({
source: "https://smee.io/SMEE_ENDPOINT_ID",
target: "http://localhost:3000/webhook",
logger: console,
});
const events = await smee.start();
console.log("Smee client started, listening for events now");

4. Test the app

At this point, I can start the full project (run docker compose up) and open a PR. I’ll see the webhook get triggered and the workflow run. And, after a moment, the result is complete! It worked!

Screenshot of a GitHub PR that was automatically closed by the agent with the generated comment.

If you’d like to view the project in its entirety, you can check it out on GitHub at mikesir87/hackathon-july-2025.

Lessons learned

Looking back after this hackathon, I learned a few things that are worth sharing as a recap for this post.

1. Yes, automating workflows is possible with agents. 

Going beyond the chatbot opens up a lot of automation possibilities and I’m excited to be thinking about this space more.

2. Prompt engineering is still tough. 

It took many iterations to develop prompts that guided the models to do the right thing consistently. Using tools and frameworks that let you iterate quickly help tremendously (thanks Mastra Playground!).

3. Docker’s tooling made it easy to try lots of models. 

I experimented with quite a few models to find those that would handle the tool calling, reasoning, and comment generation. I wanted the smallest model possible that would still work. It was easy to simply adjust the Compose file, have environment variables be updated, and try out a new model.

4. It’s possible to go overboard on agents. Split agentic/programmatic workflows are powerful. 

I was having struggles writing a prompt that would get the final agent to simply post a comment and close the PR reliably – it would often post the comment multiple times or skip the PR closing. But, I found myself asking “does an agent need to do this step? This step feels like something I can do programmatically without a model, GPU usage, and so on. And it would be much faster too.” I do think that’s something to consider – how to build workflows where some steps use agents and some steps are simply programmatic (Mastra supports this by the way).

5. Testing? 

Due to the timing, I didn’t get a chance to explore much on the testing front. All of my “testing” was manual verification. So, I’d like to loop back on this in a future iteration. How do we test this type of workflow? Do we test agents in isolation or the entire flow? Do we mock results from the MCP servers? So many questions.

Wrapping up

This internal hackathon was a great experience to build an event-driven agentic application. I’d encourage you to think about agentic applications that don’t require a chat interface to start. How can you use event-driven agents to automate some part of your work or life? I’d love to hear what you have in mind!

View the hackathon project on GitHub

Try Docker Model Runner and MCP Gateway

Sign up for our Docker Offload beta program and get 300 free GPU minutes to boost your agent. 

Use Docker Compose to build and run your AI agents

Discover trusted and secure MCP servers for your agent on Docker MCP Catalog

Quelle: https://blog.docker.com/feed/