Our original idea was to use Mineflayer with an MCP server to automate builds in Minecraft. But we had issues connecting this to online servers and making it efficient enough to be justified. We were successful in connect to local instances, but we wanted our solution to be fully in the cloud.
As a workaround, we instead use RCON to remotely connect to a live server’s console. From there we can easily send AI generate commands based on user input to very quickly create builds on a live server. All this despite the RCON wiki stating “It is dangerous to expose RCON ports to the internet. RCON is not encrypted and can be a subject to man-in-the-middle attacks.”
We gather data from user input:
Run a prompt to generate commands using the new (preview) prompt columns in Dataverse.
And run those commands via a Power Automate flow that triggers an Azure function that connects to the live server using RCON and passes along the commands:
The big benefit is that we don’t need to send an virtual player into Minecraft to build the structures, RCON directly updates the Minecraft data, which means a build can take seconds over minutes, and again, fully operates in the cloud.
Nasty hacks? Absolutely. We are hardening the process by using non-standard ports and limiting IPs to just connections coming from our own machines and the Power Platform. Even then there needs to be additional work to fully encrypt and protect our Minecraft environments.
Our goal was to get running software, which was achieved. Connecting the Power Platform to Minecraft turned out the be much more challenging then first believed.
We feel dirty, nasty, and deserving of the Nasty Hack badge.
For this hackathon we are using an old test tenant. While using the lovely little app PnP Search (I bet Mikael never heard about that one), I realised it was only uploaded 3 years ago, and never updated. No worries, just go to github and grab the newest version! However, while trying to update the app, we kept getting this stupid error.
What do you mean it is not the same name?? They are identical! I have uploaded the file, deleted it, downloaded it anew, and uploaded it 10 times now, and still I get the same error.
Luckily, there is the classic experience.
Hold the phone, did someone upload the original package with a (1) in the name? Christ on a bike, what kind of idiot would do something stupid like that?
Nevermind then. Discovered and written by Gaute Kramvik.
To make sure our employees make the right decisions if an resource report is good opportunity or not, we have crated a Power BI report that gathers all the existing data and presents them in a way they can easily read and understand. Making them better at decide if a registered request is something they should recommend or not. Using the good old Powershell scripts to create reports and saving data, thrive and thru Bice templates for deploying Azure resources and HTML to display them within the Power App and presenting them using the everlasting Power BI never goes out of fashion.
Building the Future with Multi-Agent Architecture and Model Context Protocol
The Challenge: Beyond Single-Agent AI
We wanted to build something that wasn’t just another chatbot. We wanted an AI system that could think, collaborate, and orchestrate complex workflows across multiple data sources. Single-agent systems are powerful, but they’re limited—they can only do one thing at a time, they struggle with complex multi-step tasks, and they can’t leverage specialized knowledge sources simultaneously.
We needed something cooler. Something that would make other developers say “wait, how did you do that?”
We needed multi-agent architecture with Model Context Protocol (MCP).
The Solution: Multi-Agent Orchestration with MCP Servers
We built a cutting-edge multi-agent system using Microsoft Copilot Studio, Model Context Protocol (MCP) servers, and agent-to-agent communication. Our solution demonstrates the hippest, coolest tech stack available: agents that collaborate, MCP servers that provide specialized capabilities, and a unified system that orchestrates everything seamlessly.
Here’s how we built the future.
The Architecture: Agents, MCPs, and Orchestration
Our multi-agent architecture looks like this:
User Query → Copilot Studio Agent → MCP DataAgent → Multiple Knowledge Sources → Orchestrated Response
↓ ↓ ↓ ↓ ↓
Question Scrum Assistant DataAgent MCP Azure AI Search Intelligent Answer
Server Fabric Semantic Multi-Source
Model Synthesis
Each component represents the latest in AI technology, working together to create something greater than the sum of its parts.
Step 1: Model Context Protocol (MCP) – The Foundation of Agent Communication
Model Context Protocol is the newest standard for connecting AI agents to external systems. It’s like REST APIs, but designed specifically for AI agents. MCP enables agents to discover capabilities, invoke tools, and communicate with specialized servers.
What Makes MCP Hipster-Level Cool
1. Standardized Agent Communication
Agents can discover available tools dynamically
No hardcoded integrations—everything is protocol-based
Agents can adapt to new capabilities without code changes
2. Specialized MCP Servers
Each server provides domain-specific capabilities
DataAgent MCP Server for data operations
Azure DevOps MCP Server for DevOps operations
Custom MCP servers for specialized tasks
3. Tool Discovery and Invocation
Agents discover tools at runtime
Tools are self-describing with schemas
Agents can chain tools together intelligently
Our MCP Implementation
We configured a DataAgent MCP Server that connects our Scrum Assistant to multiple knowledge sources:
The Scrum Assistant can query Fabric semantic models
Agents can access Azure AI Search indexes
Multi-source knowledge retrieval in a single query
Dynamic tool discovery and invocation
Result: Our agents aren’t hardcoded—they discover and use capabilities dynamically, making our system truly extensible.
Step 2: Multi-Agent Architecture – Agents That Collaborate
We didn’t stop at one agent. We built multiple specialized agents that can work together:
The Scrum Assistant Agent
Our primary agent, built in Copilot Studio, specializes in scrum ceremonies and backlog management:
Agent Configuration:
Model: GPT-4.1
Purpose: Support scrum team members in facilitating ceremonies, backlog management, and continuous improvement
Knowledge Sources:
Azure AI Search (code and documentation)
Fabric Semantic Model (AgileToolboxxModel)
Web search (for scrum best practices)
Agent Instructions:
You are an AI assistant designed to support the scrum team members in
facilitating scrum ceremonies, backlog management, and continuous improvement.
Skills:
1. Assist scrum teams with scrum ceremonies
2. Help with scrum best practices and coaching
3. Analyze team artifacts and provide data-driven insights
What Makes This Cool:
The agent adapts its responses based on available knowledge sources
It can query multiple sources simultaneously
It synthesizes information from different data types (structured + unstructured)
The DataAgent MCP Server
The DataAgent acts as a specialized MCP server that provides data access capabilities:
User Query: “How does the cart functionality work in the OEN project?”
Agent Discovery:
Discovers DataAgent_DataAgent tool
Discovers Azure AI Search knowledge source
Plans query strategy
Tool Invocation:
{
"tool": "DataAgent_DataAgent",
"query": "How does the cart functionality work in the OEN project?",
"sources": [
"Azure AI Search",
"Fabric Semantic Model"
]
}
Multi-Source Results:
From Azure AI Search:
Code snippets from useCart.ts
Function definitions (updateQuantity, clearCart)
Implementation details
From Fabric Semantic Model:
Project metadata
Work item references
Related features
Synthesized Response:
Cart Functionality in the OEN Project
The cart functionality is managed through core operations:
- Adding Items (with specified quantity)
- Updating Quantity (using updateQuantity function)
- Clearing the Cart (using clearCart function)
- Calculating Total (summing item prices multiplied by quantity)
These operations are typically handled in a file like useCart.ts,
which manages cart state and provides utility functions.
[Sources: Azure AI Search (gptkbindex), Fabric Semantic Model]
Result: Agents dynamically discover and use the right tools for each query, creating truly intelligent responses.
The Technical Stack: Why It’s Hipster-Level Cool
1. Model Context Protocol (MCP)
What It Is: The newest standard for AI agent communication Why It’s Cool:
Standardized protocol for agent-to-system communication
Dynamic tool discovery
Self-describing capabilities
Extensible architecture
Our Implementation:
DataAgent MCP Server for data operations
Azure DevOps MCP Server for DevOps operations
Custom MCP servers for specialized tasks
2. Microsoft Copilot Studio
What It Is: Microsoft’s latest AI agent platform Why It’s Cool:
No-code agent creation
Multi-source knowledge integration
Built-in MCP support
Real-time workflow visualization
Our Implementation:
Scrum Assistant agent with specialized instructions
Multi-source knowledge configuration
MCP server integration
Real-time agent orchestration
3. Fabric Semantic Models
What It Is: Microsoft Fabric’s semantic modeling layer Why It’s Cool:
Star schema analytics
Direct SQL query interface
Real-time data access
Integration with AI agents
Our Implementation:
AgileToolboxxModel with dimension and fact tables
Direct query access via DataAgent MCP
Real-time analytics integration
4. Azure AI Search
What It Is: Microsoft’s semantic search service Why It’s Cool:
Vector embeddings
Semantic search
Hybrid search (text + vector)
Multi-index support
Our Implementation:
Code documentation index
Vector embeddings for semantic search
Integration with agent knowledge sources
Real-World Use Cases
Use Case 1: Multi-Source Sprint Analysis
User Query: “How many work items are in different stages?”
Agent Orchestration:
Scrum Assistant receives query
Discovers DataAgent MCP Server
Queries Fabric semantic model (fact_work_item)
Groups by WorkItemState
Returns counts by stage
Response:
Work Items by Stage:
- New: 357 work items
- Active: 13 work items
- Closed: 56 work items
[Source: AgileToolboxxModel Semantic Model]
Why It’s Cool: The agent queries structured analytics data and provides instant insights.
Use Case 2: Code + Analytics Integration
User Query: “How does the cart functionality work in the OEN project?”
Agent Orchestration:
Scrum Assistant receives query
Discovers multiple knowledge sources:
Azure AI Search (code documentation)
Fabric Semantic Model (project data)
Executes parallel queries
Synthesizes results from both sources
Provides comprehensive answer with citations
Response:
Cart Functionality in the OEN Project
The cart functionality is managed through core operations:
- Adding Items (with specified quantity)
- Updating Quantity (using updateQuantity function)
- Clearing the Cart (using clearCart function)
- Calculating Total (summing item prices multiplied by quantity)
[Sources: Azure AI Search (gptkbindex), Fabric Semantic Model]
Why It’s Cool: The agent combines unstructured code documentation with structured project data to provide comprehensive answers.
Use Case 3: Real-Time Agent Workflow
User Query: “What work items are present in the closed stage?”
You are an AI assistant designed to support the scrum team members
in facilitating scrum ceremonies, backlog management, and continuous
improvement.
Skills:
1. Assist scrum teams with scrum ceremonies
- Guide teams through effective Sprint Planning, Daily Stand-ups,
Sprint Reviews, and Retrospectives
- Identify and suggest ways to improve ceremony effectiveness
2. Help with scrum best practices and coaching
- Provide guidance on agile principles
- Suggest improvements based on team data
3. Analyze team artifacts and provide data-driven insights
- Query work items, commits, and pull requests
- Provide metrics and trends
- Generate actionable recommendations
Knowledge Source Configuration
Azure AI Search:
Index: gptkbindex
Documents: 1,136
Vectorized: Yes
Semantic: Yes
Fabric Semantic Model:
Model: AgileToolboxxModel
Tables: dim_, fact_
Type: Star Schema Analytics
What’s Next
Multi-agent architecture opens new possibilities:
More Specialized Agents: Create agents for specific domains (security, performance, quality)
Agent Chains: Chain agents together for complex workflows
Custom MCP Servers: Build specialized MCP servers for unique capabilities
Agent Marketplace: Share agents and MCP servers across teams
Autonomous Operations: Agents that operate independently and collaborate automatically
But the foundation is set: we have a multi-agent system that can think, collaborate, and orchestrate complex workflows. That’s hipster-level cool.
This multi-agent architecture demonstrates the power of cutting-edge AI technology. By combining Model Context Protocol, Microsoft Copilot Studio, Fabric Semantic Models, and Azure AI Search, we’ve created an AI system that’s not just intelligent—it’s collaborative, extensible, and truly next-generation. Agents that think together, discover capabilities dynamically, and orchestrate complex workflows automatically. That’s the future of AI. That’s hipster-level cool.
How can our NGO user keep a close eye on how the EcoCraft players are doing? An operational dashboard, of course! 📊
We built out a Power BI report to surface our player and gameplay data from Dataverse using DirectQuery and visualisations. We then embedded the Power BI dashboard into our model-driven ‘Control Room’ app that the NGO user uses to control the gameplay. The user can use this to get a view of EcoCraft operations across the board.
The dashboard shows the current number of gaming sessions, session status, where in the world the players are, and information on any errors being logged.
[Full disclosure: we had intended to show a map of players around the world in the place where the EcoCraft logo is shown, but we couldn’t get the map visualisation working in our tenant. If we get time, we’ll try and fix it in time for the demo!]
Want to hear an awesome track? Play it on the room speakers!?! We’ve got an endpoint for that!
This helps keep the team spirit high and boosts everyone’s joy of life.
We value openness, which is why we also want other teams to benefit from our solution. Try it yourself! The sign with the info is posted in our base. But for those who haven’t discovered it yet, here’s a screenshot!
The Setup: A 5,454-line commit lands with the message lots of fucking about. Nobody reads it. Why would they? It’s working, right?
The Plot Twist: Buried deep in the diff, two critical bot functions were quietly replaced with this masterpiece:
async collectItems(itemType, quantity) { console.log(`[Collection] Collecting ${quantity}x ${itemType} (not implemented yet)`); await this.wait(1000); // the code equivalent of “thoughts and prayers” }
async depositItems(items, chestLocation) { console.log(`[Deposit] Depositing items (not implemented yet)`); await this.wait(1000); // vibes only } The Result: A bot that would receive orders to gather 64 diamonds, announce its intentions to the void, take a power nap, and report back: “Mission complete, boss.”
Lessons Learned:
Maybe read the 5,000-line commit (not implemented yet) in production is a cry for help await this.wait(1000) is not a substitute for functionality The commit message was accurate. It was, indeed, lots of fucking about.
Our Implementation: 10+ features across a unified building platform
Dash It Out Badge
Criteria: Great looking dashboard with 4+ graphs, gauges or KPIs showing business value
Our Implementation: Quick Stats Dashboard with 4 real-time KPIs tracking builder performance and platform engagement
When we set out to build our Minecraft construction platform, we had a simple but ambitious goal: create a single interface where builders could go from idea to execution without ever leaving the page. No context switching, no hunting through multiple tools, no juggling browser tabs. Just one comprehensive dashboard where everything you need is right at your fingertips.
The Feature Bombing badge celebrates exactly this philosophy – packing powerful functionality into a cohesive, intuitive experience. We didn’t just want to meet the “5+ features in one screen” requirement; we wanted to prove that density doesn’t mean complexity, and that more features can actually mean less friction.
But features alone aren’t enough – users need visibility into their progress and performance. That’s where the Dash It Out badge comes in. We built a Quick Stats Dashboard that displays four critical KPIs in real-time, giving builders immediate feedback on their activity and achievements. These metrics aren’t vanity numbers – they represent actual business value: user engagement (Total Builds), platform utilization (Blocks Placed), progression systems (Builder Rank), and gamification success (Achievements). Together, these KPIs tell the story of an active, engaged user base that’s getting real value from the platform.
Build Studio Plus: Four Ways to Build, One Unified Experience
Build Studio Plus isn’t just a single dashboard – it’s a complete building ecosystem that adapts to how you want to work. Whether you prefer natural language, precise forms, browsing pre-made designs, or managing your entire construction pipeline, everything lives in one seamless interface.
The AI Builder: Conversational Construction
The first thing you see when entering Build Studio Plus is our AI Builder, powered by Microsoft Copilot Studio. This isn’t a chatbot bolted onto the side – it’s a fully integrated conversational interface embedded directly in the page. You simply describe what you want to build in natural language: “Build a castle at spawn,” “Create a diamond tower,” “Make a modern house.” The AI understands your intent and translates it into actual Minecraft structures.
What makes this powerful is the context awareness. The AI knows about your available materials, your build history, your favorite blocks. It’s not just executing commands – it’s your building partner. And because it’s embedded in the same interface as everything else, the AI can reference your shopping cart, suggest using your favorited materials, or remind you about incomplete daily challenges.
The Manual Builder: Precision and Control
For builders who want exact control, the Manual Builder provides a clean form-based interface. Choose your structure type with visual icons (house, tower, castle, platform), set precise XYZ coordinates, and optionally specify your preferred material. The form includes helpful shortcuts – a “Use Spawn” button to quickly set coordinates to (0, 64, 0), or a “Random” button to pick a location automatically.
What’s clever about this integration is that the Manual Builder shares the same build queue as everything else. The structure you configure here can be added to your shopping cart alongside template selections and material purchases. You’re not executing builds one at a time – you’re composing a complete construction plan.
The Quick Catalog: Instant Inspiration
Sometimes you don’t want to design from scratch or type descriptions – you just want to browse and pick. The Quick Catalog shows pre-built structures as beautiful cards with icons, dimensions, and descriptions. Modern houses, castle towers, platforms, garden cottages – each one ready to place with a single click.
But here’s where the unified interface really shines: these aren’t isolated actions. Each catalog item can be added to your cart, combined with manual builds, paired with material purchases. The catalog isn’t a separate tool – it’s another input method in your construction workflow.
Mission Control: The Command Center
And then there’s Mission Control – the heart of Build Studio Plus. This is where the Feature Bombing badge really comes to life. Mission Control is a comprehensive dashboard that puts every aspect of your building experience in one view. No tabs, no separate pages, no need to remember where things are. Everything is right there.
On the left side, you have the Material Shop – a carousel showing all available materials with emojis and block counts. Click the heart icon on any material to favorite it. On the right side, your favorites appear instantly in a dedicated panel, beautifully displayed as chips. Below that is your Shopping Cart, showing everything you’ve added from any part of the interface – templates, manual builds, material purchases – all in one list with a total block count and a single “Build Package” button.
The Block Quotas section displays visual progress bars for each material type, showing at a glance how many blocks you have versus your limits. Need more? The “Purchase More Blocks” button opens a modal where you select your material and drag a slider from 100 to 10,000 blocks. The preview updates in real-time, showing the price calculation as you adjust the quantity. Hit “Add to Cart” and it joins everything else in your unified shopping cart.
Build History tracks your recent activity with rich details that go far beyond simple construction logs. Each entry shows coordinates, materials, block counts, and timestamps, but also categorizes the source – was it built from an AI prompt, a manual form, or a catalog template? Color-coded badges make this instantly recognizable. The history isn’t just builds either; material purchases appear in the timeline too, showing when you bought 500 diamond blocks for 50 coins. Every entry has “Rebuild” and “Share” buttons for quick actions.
But the real intelligence is in the companion panels. The Activity Summary breaks down your engagement into weekly and all-time metrics: builds completed this week (8), blocks placed (2,450), materials purchased (1,200). All-time stats show your total spending (387 coins), purchase count (23), and even identifies your favorite material (Diamond – no surprise there). This isn’t just data for data’s sake – these metrics directly correlate to platform health indicators like user retention, feature adoption, and monetization.
The Top Templates panel reveals usage patterns by ranking your most-used templates with build counts. Castle templates lead at 5x usage, followed by Towers (3x) and Houses (2x). This simple visualization provides both user value (quickly see what you build most) and business intelligence (which templates drive engagement). The Server Status widget displays real-time information about the Minecraft server, and the Daily Challenge shows your progress toward today’s goal with a visual progress bar.
The Build Templates Library shows six pre-designed structures – from simple platforms to legendary palaces – each with difficulty badges and block requirements. Click any template and a professional modal dialog opens (no annoying alerts here!) where you can review the details and add it to your cart with a single button press.
Quick Stats gives you four key metrics at a glance: total builds completed, blocks placed, your builder rank, and achievements earned. These aren’t buried in a profile page somewhere – they’re right there in your workflow, providing constant feedback and motivation.
Build History tracks your last three constructions with full details – coordinates, materials, block counts, and timestamps. Each entry has “Rebuild” and “Share” buttons, making it trivial to repeat successful builds or show off your work. The Server Status widget displays real-time information about the Minecraft server, and the Daily Challenge shows your progress toward today’s goal with a visual progress bar.
The “All in One Place” Philosophy
What makes this work isn’t just having lots of features – it’s having them work together as a system. When you favorite a material in the carousel, it immediately appears in your favorites panel. When you add a template, it joins your cart alongside any manual builds or material purchases you’ve queued up. Your stats update based on your history, which is always visible. The server status tells you if you can actually execute your build right now.
There’s no cognitive load from switching contexts. You don’t need to remember “where was that button again?” or “which tab has my cart?” Everything flows naturally because it’s all part of one unified interface. You can browse materials while checking your stats, add a template while reviewing your history, purchase blocks while monitoring your quotas.
This is what Feature Bombing is really about – not cramming features in for the sake of it, but creating a dense, powerful interface that makes complex workflows feel effortless. When everything is in one place and everything works together, users don’t feel overwhelmed by the number of features. They feel empowered.
Technical Simplicity Behind the Experience
The beauty of Build Studio Plus is that this comprehensive experience is built with remarkably simple technology. Pure vanilla JavaScript handles all the interactivity – no complex frameworks needed. Bootstrap 5 provides the responsive grid and carousel component. Bootstrap Icons give consistent visual language throughout. The entire state management system is just three variables: a Set for favorites, an array for the cart, and an object to track the selected template.
javascript
let favorites = new Set();
let cart = [];
let selectedTemplate = null;
```
Material data lives in a simple object structure that drives both the shop carousel and the purchase modal:
```javascript
const materialData = {
stone: { emoji: '⚫', name: 'Stone', blocks: 100 },
diamond: { emoji: '💎', name: 'Diamond', blocks: 50 },
// ... 8 materials total
};
The shopping cart updates are handled by a single function that calculates totals, renders cart items with remove buttons, and shows or hides the summary based on cart state. Modal dialogs use Bootstrap’s built-in modal component with custom onclick handlers. The carousel rotates through materials automatically but also responds to manual navigation.
What’s notable is how much functionality emerges from these simple building blocks. The live preview in the purchase modal is just reading the slider value and looking up material data. The favorites display is iterating through a Set and creating chip elements. The cart total is a simple reduce operation. Simple code, sophisticated experience.
Beyond the Badge
Build Studio Plus represents more than just claiming a Feature Bombing badge. It’s a proof of concept for how modern web interfaces should work. Users don’t want separate tools for each task – they want integrated workspaces where everything connects. They don’t want to context switch – they want to flow through their work naturally. They don’t want to learn complex systems – they want power that feels simple.
We achieved Feature Bombing not by cramming features in, but by understanding what builders actually need and giving them a single place where all of it works together. The AI Builder for natural language, the Manual Builder for precision, the Quick Catalog for inspiration, and Mission Control for orchestrating it all – each one useful on its own, but together forming something greater than the sum of its parts.
That’s the real lesson of Feature Bombing: features don’t bomb when they explode with possibilities. They bomb when they explode into chaos. Keep everything connected, keep it in one place, and give users the power to compose their own workflows. That’s how you turn “5+ features” into “everything I need.”
The Numbers
Build Studio Plus includes over 10 distinct features across four major interfaces, all accessible from a single starting point. The AI Builder, Manual Builder, Quick Catalog, and Mission Control Dashboard together provide multiple paths to the same goal – getting your Minecraft structures built efficiently. The codebase is surprisingly compact at around 750 lines of implementation code, proving that thoughtful architecture matters more than complexity.
Badge Status: Claimed
Build Studio Plus proves that Feature Bombing isn’t about quantity for quantity’s sake. It’s about recognizing that users have complex workflows, and the best interfaces don’t just support those workflows – they anticipate them. When you can go from “I want to build something” to “I have a complete build plan ready to execute” without ever leaving a single interface, that’s when features stop feeling like additions and start feeling like superpowers.
We didn’t set out to build ten features. We set out to build one cohesive experience that happened to need ten features to feel complete. That’s the difference between feature bombing and Feature Bombing.
We wanted to make sure our customers felt confident that their builds are secured and that they have ownership when using 404DiamondsNotFound for their Minecraft building needs.
That’s why we decided to take advantage of the signing functionality from OneFlow. They had a ready to use out of the box solution for Power Platform and Dynamics, easy to use document templates and a secure e-signature solution.
Then we added their contract widget to our Minecraft Building table’s form. From here our agents can create a contract manually, control the content and send it to the customer for signing.
Creating the contract
Double checking the contract details, using a message template, and sending to the customer.
An easy signing process for our customers
We also wanted to build a flow which updated the customers Minecraft Building status when the contract was signed. Which we could do using a flow:
