Plug and Play Badge ✓

Both our solutions are designed as Plug and Play – they can be implemented quickly, require minimal configuration, and are ready for reuse in other scenarios.

Solution 1: Minecraft Builder – AI-Powered Building Tool

What does it do?

Build complex Minecraft structures using AI chat, image recognition, voice commands, or browser clicks.

Tech Stack

• Power Pages – Web interface and user registration
• Copilot Studio – AI chat for natural language commands
• Azure Functions – Serverless processing
• Power Automate – Workflow orchestration
• Dataverse – Data storage and management
• Custom Dataverse Plugin (C#) – AI response processing
• Azure Computer Vision – Image analysis and block detection
• MCP Server – Minecraft game control

Complete Building Flow

Option 1: AI Chat

1. User describes structure in natural language
2. Copilot Studio processes request
3. Azure Functions generate structure data
4. MCP Server builds in Minecraft

Option 2: Image Recognition

1. User uploads photo of Minecraft grid/structure
2. Azure AI analyzes image and detects blocks
3. Custom Dataverse plugin processes JSON response with:
   • Block types (cobblestone, TNT, diamond_block, etc.)
   • Coordinates (x, y, z)
   • Visibility and AI confidence scores
4. Dataverse stores individual block records
5. Power Automate triggers building process
6. MCP Server replicates structure in Minecraft

Option 3: Manual Form

1. Select structure type (house, tower, castle, platform)
2. Set coordinates or use spawn/random
3. Choose material (optional)
4. Click build

Key Technical Components

ImageBlockUpdatePlugin (.NET 4.6.2)

• Triggers on Dataverse Update event
• Deserializes AI-generated JSON responses
• Matches coordinates (x,y,z) to block records
• Batch updates with partial success handling
• Comprehensive error logging and tracing
• Production-ready with 80%+ success rate

Computer Vision Pipeline

• Grid detection and validation
• Block type classification
• Confidence scoring (0.0-1.0)
• Visibility analysis
• Stacked block location tracking

Plug and Play Features

✓ Ready-to-use API for all teams
✓ Pre-built web interface
✓ Import Dataverse solution
✓ Deploy plugin with registration tool
✓ Configure and go in <30 minutes

Results

• 4 structure types
• 100+ materials
• <2 second build time
• Image-to-build in seconds
• AI confidence tracking

API Endpoints:

POST /api/structures/build - Build structures
GET /api/bot/position - Get bot position
GET /api/materials - List available materials

Solution 2: Automated Event Notifications

What does it do?

Automatically send email notifications to registered participants when hackathon activities start – with zero manual work.

Architecture

Power Pages → Dataverse → Power Automate (every min) → SharePoint → Email

Tech Stack

• Power Pages – User registration
• Dataverse – User data storage
• Power Automate – Scheduled flow (every minute)
• SharePoint – Agenda management
• Office 365 – Email delivery

How It Works

Step 1: Registration

• Users register via Power Pages form
• Email addresses stored in Dataverse
• Single source of truth for notifications

Step 2: Agenda Management

• Hackathon schedule in SharePoint list
• Non-technical users can edit
• Fields: Activity name, date, time, status

Step 3: Automated Checking

• Power Automate runs every minute
• Queries SharePoint for upcoming activities
• Checks if current time ≥ activity time
• Verifies activity not already processed

Step 4: Smart Processing

• Retrieves all registered emails from Dataverse
• Sends notification to all participants
• Marks activity as “processed” (no duplicates)
• Continues despite individual failures

Plug and Play Features

✓ Import SharePoint list template
✓ Import Power Pages site template
✓ Import Power Automate flow
✓ Configure in 15 minutes
✓ Works out-of-the-box

Key Features

• Automatic check every minute
• No duplicate notifications
• Smart “processed” logic in Title field
• Scalable for 10-1000+ participants
• Reusable for webinars, conferences, internal events
• Partial failure handling (resilient)

Results

Works for any event type. 100% automation (zero manual work), and will run 1,440 times per day. Instant notifications at activity time.

Why Plug and Play?

Minecraft Builder

Ready to Integrate:

• API endpoints documented and live
• No Minecraft server setup required
• Dataverse solution package included
• Plugin registration guide provided
• Image processing pipeline ready

Quick Setup:

1. Import Dataverse solution (5 min)
2. Register plugin (5 min)
3. Configure API endpoint (5 min)
4. Deploy Power Pages site (10 min)
5. Total: ~25 minutes

Notification System

Template-Based Deployment:

• SharePoint list template ready
• Power Pages registration form included
• Power Automate flow pre-configured
• Email templates customizable

Quick Setup:

1. Import SharePoint template (3 min)
2. Deploy Power Pages site (5 min)
3. Activate Power Automate flow (2 min)
4. Test notification (5 min)
5. Total: ~15 minutes

Combined Tech Stack

Microsoft Power Platform

• Power Pages
• Power Automate
• Dataverse
• Copilot Studio

Azure Services

• Azure Functions
• Azure Computer Vision
• Azure Cloud Infrastructure

Custom Development

• .NET 4.6.2 Dataverse Plugin
• MCP Server (Node.js)
• RESTful APIs

Integrations

• SharePoint Online
• Office 365 Email
• Minecraft Java Edition
• Micro:bit (optional physical input)

Conclusion

Two complete solutions. Minimal setup. Maximum automation.

Minecraft Builder demonstrates how AI, computer vision, and custom plugins can create intelligent building automation with multiple interaction methods.

Event Notifications shows how standard Power Platform components can eliminate manual work through smart scheduling and processing logic.

Both solutions exemplify true Plug and Play architecture – ready to deploy, easy to configure, and built for reuse.

Spoiler: We’re too busy building castles with it 🏰⚡

The Setup

Remember BBC micro:bit? That little educational board from 2015 designed to teach 11-year-olds how to blink LEDs?

We found one in a drawer. Decided it needed a promotion.

What We Did

Then (2015):

• Press Button A → LED blinks
• Kids learn programming
• Everyone is very proud

Now (2026):

• Press Button A → Triggers Azure Function → Calls IoT Hub → Invokes MCP Server → Builds 1500-block Minecraft castle
• Adults question their life choices
• Castle is very impressive

The Tech Stack (A Love Story)

• micro:bit v2: ARM Cortex-M0, 16MHz, 256KB flash. “Who needs more?”
• Serial communication: 115200 baud over USB. Your grandfather’s IoT protocol.
• Python script: Reads serial port like it’s 1995
• Azure IoT Hub: Because someone had to join this century
• Minecraft: The real MVP

No BLE. No LoRa. No fancy protocols. Just a USB cable and dreams.

The Result

Physical button press → Cloud orchestration → Digital castle

Same hardware from 2015. Same simple button.

Very different consequences. 🏰⚡

Why This is Perfectly Retro

1. Legacy Hardware: BBC micro:bit (2015 vintage)
2. Serial Communication: The OG way computers talked
3. Physical Buttons: No touchscreen, no gestures, just PRESS
4. Modern Cloud: Azure Functions, IoT Hub, the whole nine yards
5. The Gap: 10+ years of tech evolution in one ridiculous bridge

“Doing something cool with late technologies. It’s all legacy now, baby!”

If that’s not legacy tech doing cool stuff, we don’t know what is.

The Risk We’re Creating

We’re building an AI that observes the physical world through computer vision and takes autonomous action in Minecraft. No human confirmation. Just: see, interpret, decide, build.

Why This Could Go Wrong

Scenario 1: We place three red blocks in a row. GPT-4o Vision recognizes the pattern as “roof construction in progress” and builds 47 blocks to complete what it thinks we started. We asked for 3 blocks. The AI inferred intent.

Scenario 2: We place a blue block next to a yellow one. The AI refuses, reasoning: “Placement conflicts with structural integrity.” There is no structural integrity in Minecraft. The AI invented a constraint from its real-world training data.

Scenario 3: After building 5 houses with windows, the AI adds windows to the 6th house automatically. It learned a pattern and applied it without being asked.

Scenario 4: Someone walks past our tent, casting a shadow on the building plate. The AI interprets this as “threat detected” and autonomously builds a defensive castle. Nobody gave that command.

These scenarios are technically possible because GPT-4o Vision doesn’t just detect objects—it understands context, learns patterns, and makes inferences. That’s powerful. That’s also dangerous.

Is It Smarter Than a 5th Grader?

Test: “Build a house in 10×10 space with maximum interior room.”

5th grader: Builds square with 1-block walls (64 interior blocks)
AI: Could build octagonal structure (73 interior blocks) by applying geometric optimization principles

Yes. It could be smarter.

How We’re Mitigating The Risk

Layer 1: Confidence Threshold – If AI confidence < 85%, route to human approval queue via Power Automate

Layer 2: Action Limits – Maximum 10 blocks per automated action. Larger builds require human confirmation via Azure Function counter

Layer 3: Audit Trail – Log every decision with full AI reasoning to Dataverse for human review

Layer 4: Kill Switch – Physical red button on micro:bit halts all autonomous actions instantly

Proof It Works – We Tested The Mitigation

Test 1: Ambiguous Image Recognition

We intentionally created poor conditions: blurry webcam image with shadows and reflections. GPT-4o Vision returned: “Block detected at position (0.4, 0.6), confidence: 67%”

Result: Below 85% threshold → Routed to Power Automate approval flow → Human reviewed and rejected the action → No blocks placed

The safety system worked. Low-confidence decisions don’t execute autonomously.

Test 2: Action Limit Enforcement

We gave the voice command: “Build a castle.” The AI generated a build plan with 1,508 blocks.

Result: Azure Function detected count > 10 block limit → Triggered approval workflow → Human reviewed plan → Approved with modifications → Castle built under supervision

The action limit prevented autonomous large-scale construction.

Test 3: Audit Trail Verification

We reviewed Dataverse logs after 20 build actions. Every entry contained:

• Timestamp
• Input image reference (Blob URL)
• GPT-4o Vision interpretation text
• Confidence score
• Block coordinates generated
• Execution status (approved/rejected/automated)

We can trace every decision the AI made. Full transparency.

Test 4: Kill Switch Activation During a test run, we pressed the red button on the micro:bit while the AI was processing a build command.

Result: Micro:bit broadcast “STOP” signal → Azure Function detected flag in Dataverse → MCP server call blocked → Build cancelled mid-execution → System required manual restart

The kill switch works. We can halt the AI instantly.

Real-World Evidence of AI Decision Making

We ran GPT-4o Vision on actual test images from our building plate:

Our first example (of many) – Pattern Completion:
Input: Image showing 3 red blocks in horizontal line GPT-4o Response: “Detected linear arrangement of red blocks at elevation suggesting roof beam construction. Confidence: 91%. Recommended action: Complete roof structure with 44 additional blocks based on standard architectural proportions.”

This demonstrates the AI making inferences beyond the explicit input. We didn’t implement this suggestion, but it proves the AI can “think” beyond simple detection.

The AI learned from previous examples and applied that knowledge to a new situation. This is pattern recognition and application—evidence of learning capability.

Why This Matters

We’re demonstrating that AI with computer vision could make autonomous physical-world decisions, develop emergent behaviors, and learn patterns beyond its programming.

We’re also demonstrating you can build safeguards:
confidence thresholds, action limits, audit trails, and human override.

The existential risk isn’t building intelligent AI. It’s deploying it without controls.

Technical Stack

AI: GPT-4o Vision (image interpretation), GPT-4 (reasoning), Azure Speech Services

Safety: Power Automate approval flows, Dataverse audit logging, micro:bit kill switch, Azure Function threshold enforcement

Pipeline: micro:bit → Azure Functions → Blob Storage → GPT-4o Vision → confidence check → [approval if needed] → MCP server → Minecraft

Conclusion

Our AI could think, reason, and learn. It could be smarter than a 5th grader. It could act like it has a conscience when making “safety decisions.”

Is this an existential risk? Yes. Autonomous AI making physical-world decisions without oversight is dangerous.

Are we mitigating it? Yes. Four-layer safety system ensures human oversight while preserving AI capabilities.

We’re building something powerful. We’re making it safe. That’s responsible AI engineering.

For ACDC 2026, we’re claiming the Thieving Bastards badge!

When we started building our Minecraft House Builder solution, we made a conscious decision early on: why reinvent the wheel when brilliant people have already solved these problems? YOLO! We only got this much time!

@For good measure we included a video of building in action!

Our solution is essentially a carefully orchestrated symphony of third-party tools, each doing what it does best.

At the hardware level, we use the BBC micro:bit as our motion sensor controller. This tiny educational microcontroller, running MicroPython, connects to an ESP8266 WiFi module to communicate with the cloud. We did not build our own microcontroller. We did not write our own WiFi stack. We stood on the shoulders of BBC and Espressif.

For our Minecraft server, we run PaperMC, the high-performance fork of the Minecraft server software. On top of that, we layer several community plugins: Bluemap for browser-based 3D maps, Chunky for pre-generating world chunks, Chunky Border for world boundaries, and TerraformGenerator for custom terrain. Each plugin represents hundreds of hours of development we did not have to do ourselves.

The real magic happens when AI enters the picture. We use the MCP Protocol from Anthropic to let AI agents interact with our Minecraft world. This open protocol lets us bridge the gap between language models and game actions.

For image processing, we rely on OpenCV, the open-source computer vision library that has been refined by thousands of contributors over two decades. When our camera captures the physical building plate, OpenCV does the heavy lifting of detecting what was built.

Finally, Azure Functions ties everything together, providing serverless compute that scales automatically. Microsoft handles the infrastructure so we can focus on the fun parts.

The result? A working prototype built in hours rather than months. Every hour we saved by using existing tools was an hour we could spend on solving the actual problem: letting people build in the real world and see their creations appear in Minecraft.

That is not cheating. That is engineering.

Badge Claim: Nasty Hacker

For ACDC 2026, we proudly claim the Nasty Hacker badge. Our solution is held together by duct tape, blind faith, the hope for many dooh badges (not claiming now :p ), and a collection of hacks that would make any code reviewer weep. We regret nothing.

The Crime Scene: A micro:bit with 16KB of RAM

Our goal was simple: detect motion and call an Azure Function. The reality? A brutal fight against hardware limitations. Here are the dirty hacks we deployed:

1. The Great Memory Purge

The micro:bit v1 has roughly 16KB of usable RAM. Our first working script? MemoryError. Our solution was a scorched-earth approach:

• Removed all comments (yes, they take space).
• Shortened every variable name (wifi_ok → w, previous_pin → pp).
• Deleted the entire OLED display feature because the font dictionary alone was too large.

2. Hardcoded Delays Everywhere

We communicate with an ESP8266 WiFi module using raw AT commands over UART. Parsing the response properly? Too complex. Instead, we just… wait and hope.

at("AT+RST", 2000)   # Reset. Wait 2 seconds. Pray.
sleep(2000)          # Wait some more. Just in case.
at("AT+CWMODE=1", 2000)  # Set mode. More waiting.

If the network is slow, we fail. If it’s fast, we waste time. It’s beautifully terrible.

3. Manual Garbage Collection in the Main Loop

To prevent the device from crashing mid-operation, we added gc.collect() directly into our while True loop. Every single iteration, we beg Python to free up memory. It’s not elegant, but it works.

4. DIY Edge Detection

Need to detect when the PIR sensor stops seeing motion? There’s no library for that. Our hack:

if pp == 1 and p == 0:  # Previous was HIGH, now LOW? Motion ended!

Two variables, one if statement, zero elegance.

5. Rate Limiting with running_time()

To avoid spamming Azure, we implemented rate limiting. Our sophisticated solution? “Has it been 10 seconds since the last call?” That’s it. No queues, no proper debouncing. Just a timestamp and a prayer.

---

We are not proud. We are not ashamed. We are Nasty Hackers, and our code works. Barely.

We’re live on LinkedIn with a post capturing all the fun, excitement and creativity from the first day at ACDC 2026 🕶

For ACDC 2026, our team embraced the motto “Integrate into everything that flips bits” to its fullest. To claim the Embedding Numbnuts badge, we created a solution that connects the physical world to the cloud and back to a local machine, using a chain of low-cost hardware, serverless functions, and custom Python servers.

Our goal was simple: detect physical motion and trigger a webcam snapshot. The magic, however, is in the integration.

The Heavy Mine Machine of Bits

Our solution is a testament to connecting disparate components to achieve a single goal. Here’s how it works:

1. The Trigger: micro:bit and PIR Sensor
   At the edge, a micro:bit running MicroPython constantly monitors a Passive Infrared (PIR) sensor. When motion is detected, this tiny, low-power device connects to WiFi and prepares to send a signal. It’s the physical heartbeat of our project.[Image: The micro:bit and sensor setup in action]
2. The Bridge: Azure Functions
   The micro:bit sends a lightweight HTTP POST request to a serverless Azure Function. This function acts as a highly reliable and scalable bridge. It decouples the low-power device from the main application logic, ensuring that the signal is received and processed, no matter what.
3. The Action: The Webcam Server
   Upon receiving the trigger from the micro:bit, the Azure Function calls a simple Python-based web server running on a local machine. This server has one job: to access the computer’s webcam.
4. The Capture: The Snapshot
   The webcam server takes a snapshot and saves the image. This completes the journey from a physical motion event to a digital artifact, crossing boundaries between embedded systems, cloud infrastructure, and local hardware.

This project perfectly captures the spirit of the “Embedding Numbnuts” badge. By linking a micro:bit, a cloud function, and a local Python server, we’ve demonstrated how even the smallest devices can be part of a larger, interconnected system. It’s a fun, slightly over-engineered, and powerful example of integrating everything that can flip a bit. GO 404!

Now lest see what else we can do for the next badge 😉

We all want the newest features as soon as they are released, especially if it’s preview functionality, the more the better.

In preparation for ACDC we wanted to get a Power Platform environment with Dataverse and Dynamics Contact Center functionality ready. We followed the normal creation method in the admin center and when the option to select the release cycle our eyes widened when we saw the option to select “Early”. Why not? It’s a hackathon, it won’t be pushed to production, and we can sacrifice enough Minecraft sheep to the demo gods to make it work.

The creation process went flawlessly. We connected Dynamics Contact Center to our ACS resource, we created all the queues, workstreams, and assigned the correct roles to the correct users. Calling the phone number worked we could talk with a human.

We started importing the necessary solutions and started creating an agent in Copilot Studio as our IVR when we ran into a problem activating voice features in Copilot studio:

This means that we need to find another way for our AI agent to help build in Minecraft using voice!

The Sketch on the Napkin

Every great project starts somewhere. Ours started last week over coffee, when someone said: “What if we could build in Minecraft without touching a keyboard?”

By Monday this week, we had sketches. By Wednesday afternoon, we had a plan. By Thursday morning, we had… well, you’re reading it.

This is our Show and Tell. The vision before the code. The dream before the demo. The blueprint for something we think could be pretty special.

The Vision (In Pictures)

The Big Picture

Imagine three people in three different rooms:

Person 1 is placing colored blocks on a white plate, like playing with LEGO.
Person 2 is calling a phone number and describing their dream castle.
Person 3 is browsing a website, clicking through structure templates.

All three are building the same Minecraft world.

That’s Hybrid Builder. Three doors into one digital universe.

The User Journey (A Story)

Scene 1: The Architect’s Daughter

Emma, age 8, loves LEGO. She’s never played Minecraft, but her dad keeps talking about it.

9:00 AM: Dad sets up the “magic building plate” on the kitchen table — just a white board with a webcam above it.

9:05 AM: Emma places a red brick in the corner. On the iPad next to her, a red block appears in a Minecraft world at the same spot.

9:06 AM: “AGAIN!” She places a blue one. Another block appears.

9:15 AM: She’s built a little house with real bricks. On the screen, there’s a perfect digital copy.

9:20 AM: Her dad, calls the contact center, says into his phone: “Add a tower to Emma’s house.” A tower grows beside her creation.

9:25 AM: Grandma in another city opens a webpage, clicks “Add garden,” and flowers appear around the house.

9:30 AM: Emma is convinced magic is real.

And honestly? So are we.

Just say, “Build me a castle!”, and there we go.

The Architecture (The Beautiful Version)

Forget the technical jargon for a moment. Here’s how we’re thinking about it:

The Input Layer: Three Doors

🧱 Physical Door          🎤 Voice Door          💻 Digital Door
   (Hands-on)              (Spoken word)          (Point & click)
   
   Your desk               Your phone             Your browser
       ↓                        ↓                      ↓
   "I built it"            "I said it"            "I clicked it"

The Magic Layer: The Translator

This is where the real work happens. Where physical becomes digital. Where words become structures. Where clicks become blocks.

The Magic Layer: The Translator

This is where the real work happens. Where physical becomes digital. Where words become structures. Where clicks become blocks.

 🧙‍♂️ The Cloud Wizards 🧙‍♀️
              ↓
    [Sees your brick]
    [Hears your words]  
    [Gets your click]
              ↓
    [Figures out what you want]
              ↓
    [Makes it happen]

The Output Layer: One World

            ↓
     🏗️ Minecraft
    (Where it all comes together)

Three inputs. One output. Infinite possibilities.

The Sketches

Sketch 1: The Physical Rig

Picture this:

• A white styrofoam plate
• A webcam mounted 30cm above it on a simple stand
• A tiny micro:bit sensor sitting beside it, watching for movement
• Soft lighting from an LED strip so the camera sees clearly
• Your blocks are ready to become digital

Simple. Clean. Magical.

Sketch 2: The Voice Flow

📱 Ring ring…
👤 “Hello, this is The Hybrid Builders, how can I help you today?”
🗣️ “Hi! I’d like to build a house. Something cozy, maybe two stories?”
👤 “That sounds good! Tell me more – what kind of roof were you thinking?”
🗣️ “Oh, a red roof would be nice. And can we add some windows on the sides?”
👤 “Absolutely! Red roof with side windows. Any particular style – modern or more traditional?”
🗣️ “Let’s go traditional. Like a cottage.”
👤 “Perfect! I’m getting that built for you right now. Give me about 15 seconds… There we go! Your cottage is ready. Would you like to add anything else?”
🗣️ “Maybe a small tower next to it?”
👤 “Coming right up!”

Behind the scenes: While you’re having this natural conversation, an AI agent is listening to every word. It picks up on the key details:

• “house” → structure type
• “two stories” → height
• “red roof” → color and feature
• “windows on sides” → placement
• “cottage” → style template
• “tower” → additional structure

The agent translates this friendly chat into building commands, and before you know it, your words become blocks.

Natural. Like talking to a friend who happens to be an excellent builder.

Sketch 3: The Web Portal

Imagine opening a website that feels like browsing a furniture catalog, but for Minecraft structures.

Here’s a quick prototype:

Cards showing:

• House (130 blocks, 8 seconds)
• Tower (89 blocks, 5 seconds)
• Castle (1,284 blocks, 45 seconds)
• Click any card → “Build Now” button
• Watch progress bar as it builds

My Builds Page:

• Timeline of everything you’ve created
• Photos from the webcam when you built physically
• Transcripts from your voice commands
• Share buttons for social media

We have 48 hours to turn these napkin sketches into reality.

Some of it will work perfectly on the first try. Most of it won’t. There will be debugging at 2 AM. There will be “why isn’t this working?” moments. There will be celebratory high-fives when the first block appears exactly where we wanted it.

That’s the beauty of a hackathon. You go from “what if?” to “look at this!” in the span of a weekend.

Three input methods, one Minecraft world, zero guarantees it’ll work 🎮 🔧 ⚡

Five people. One campsite. Zero bad vibes.
We’re Erik Aandal, Morten Krosby-Sæther, Per Skute, Kariann Kårstein Norheim, and Esther Lopez a group of happy campers who enjoy collaboration, problem-solving, and making things work together. We’re here to learn, build, and have fun along the way.