Amplifier · Digital Twin Universe

It Works When Deployed

A disposable world to prove your app is real

The Gap

The agent says “it works” — but it only ever checked its own build machine

Digital Twin Universe is an Amplifier bundle that stands up a complete, isolated world from one declarative YAML profile — built to answer a harder question: does this actually work when deployed?

First, proof this is real software — not a concept deck.

Shipped, Not Speculative

DTU is real, working software with a substantial engine behind it

62 commits from 2026-03-25 to 2026-05-22, released as v0.3.0 (Alpha) on 2026-05-15. A ~4,397-line Python core, exercised by a tiered test suite.

So the system is real — but does “tests pass” mean it works?

62

commits (Mar–May 2026)

0.3.0

version (Alpha)

~4,397

lines of Python engine

262

tests across 42 files

The Blind Spot

“Tests pass” on the build box isn’t “it works”

By default the verdict is measured in the same environment and context the code was built in — what the DTU README calls “context poisoning.” Nobody has confirmed a real user can clone, install, render the UI, and run it off the dev machine.

Closing that gap starts with a whole world from one file.

Mechanism · The World

One YAML profile stands up a complete, isolated world on demand

A DTU is defined by a single declarative profile that declares the services, networking, and provisioning to launch an ephemeral Incus environment. The repo ships 8 example profiles.

The world exists — now prove a human can actually reach it.

# amplifier-chat.yaml (excerpt)
base:
  image: ubuntu:24.04
access:
  ports:
    - host: 8410
      container: 8410
      path: /chat/
readiness:
  url: http://localhost:8410/ready
  expect_json: {ready: true}

Mechanism · The Proof of Reach

check-readiness proves the app is up inside AND from the host

Since 2026-04-07, check-readiness verifies both in-container readiness and host-side access-port reachability — confirming Incus proxy devices work and traffic flows end-to-end through the port forwards.

Verified reachable — now hand it to agents that test the real UI.

1

In-container readiness

Probe the service inside the Incus environment.

2

Host-side access port

Confirm the forwarded port is reachable from the host.

3

End-to-end through the proxy

Traffic really flows through Incus proxy devices.

The Pipeline

The reality-check pipeline pairs two agents to test a live app

The reality-check-pipeline recipe calls dtu-profile-builder to explore a repo, generate a profile, and launch the world — then hands off to reality-check’s browser-tester to verify the running UI.

Why two agents? Because localhost inside the runner is a dead loopback.

dtu-profile-builder — a 27,466-byte agent that explores the repo, generates the profile, and launches the environment.
Dual URLs — it surfaces both the user-facing localhost URL and a runner-internal container_ip URL so the tester can actually reach the app.
browser-tester — the reality-check bundle’s acceptance-test orchestrator, used to verify web UIs after deployment.

The Payoff

A real browser drives the live UI — so “done” means “works when deployed”

dtu-profile-builder launches the disposable world and hands off the runner-internal URL; the browser-tester then drives a real browser against the live UI — navigating, interacting, screenshotting, and reporting structured results. The agent’s “it works” becomes a proven verdict.

The lesson generalizes beyond DTU itself.

The Pattern

Separate the world you build in from the world you ship to

Stand the app up somewhere clean and isolated, verify it’s reachable end-to-end, and let a machine open the real UI before you call it done — because “works on the machine that built it” was never the bar.

Sources

Research Methodology

Data as of: based on repo state through 2026-05-22 (latest commit 4a37c1a).

Feature status: DTU v0.3.0 — Development Status :: 3 – Alpha.

Primary repositories: robotdad/amplifier-bundle-digital-twin-universe (remote confirmed; README install references microsoft/amplifier-bundle-digital-twin-universe@main); pipeline claims sourced to microsoft/amplifier-bundle-reality-check.

Commands run:

git remote -v — confirmed source repo; grep -n microsoft README.md
git rev-list --count HEAD (62 commits); git log --reverse --format='%ai %h %an %s' (first/last dates)
cat pyproject.toml (version 0.3.0, Alpha); git log 01d36be -1 (release v0.3.0)
find src -name '*.py' -exec wc -l {} + (~4,397 lines; engine.py 1,784)
grep -rh 'def test_' tests/ | wc -l (262); find tests -name '*.py' | wc -l (42)
grep -nE '@main.command' src/.../cli.py (9 commands); find profiles .amplifier -name '*.yaml' (8 profiles)
cat profiles/amplifier/amplifier-chat.yaml (ports 8410, /chat/, readiness expect_json)
git show e1017a4 --stat (host-side access verification); git show 97b8024 / 4e5fa2c (browser-tester lifecycle)
grep -nE 'agent:' recipes/reality-check-pipeline.yaml; wc -c agents/dtu-profile-builder.md (27,466 bytes)

Gaps: reality-check pipeline details come from the adjacent microsoft/amplifier-bundle-reality-check repo, not the DTU repo. agent-browser tool’s own repo was not independently verified. Mock-image catalog (M365, Slack, GSuite) is marked TBD in the README.

Primary contributors: David Koleczek (45 commits), Brian Krabach (12), plus Salil Das, Dan Koleczek, Michael J. Jabbour, manojp99; authored by the Microsoft MADE:Explorations Team.