Inside the AI That Plays RollerCoaster Tycoon: How Agentic Systems Control Legacy Apps

AI playing RollerCoaster Tycoon by itself: why this demo matters for agentic systems and legacy apps

A short Reddit post pointed to a live X (Twitter) broadcast of an AI playing RollerCoaster Tycoon by itself, alongside an explanation from the team behind it. The discussion is here: Reddit thread, with the explainer at labs.ramp.com/rct.

Beyond the novelty, this touches a serious question in AI: can agentic systems (AI that decides and acts in loops) reliably control legacy software through the screen, the way humans do with mouse and keyboard? If so, it unlocks automation for the “long tail” of Windows apps, business tooling, and even games that were never built with APIs in mind.

What the RollerCoaster Tycoon demo appears to show

The post links to a broadcast of an AI autonomously running RollerCoaster Tycoon, a classic PC sim. The team also shared a write-up on how they did it. Exact technical details (models used, error rates, hardware) are not disclosed in the Reddit content itself, so treat this as a conceptual summary rather than a teardown.

AI playing RollerCoaster Tycoon by itself

Why it’s interesting: games are messy, dynamic interfaces. If an agent can perceive the UI, plan goals, and reliably act via mouse/keyboard, that same approach can transfer to many desktop apps with minimal changes.

How agentic systems typically control legacy apps

While the Reddit post doesn’t enumerate the stack, most working systems in this space follow a similar pattern:

• Screen perception: capture the window and use vision (computer vision or vision-LMs) to recognise buttons, text, and UI state.
• Planning: convert goals into steps (e.g., build a ride, set prices) using an agent loop. An agent loop means observe – think – act – repeat.
• Action: simulate precise mouse and keyboard input at OS level to interact with the app in real time.
• Verification: check the new screen state to confirm the action worked; if not, backtrack or try a different tactic.

This is conceptually similar to robotic process automation (RPA), but with more general-purpose perception and decision-making. In AI terms, you’ll hear “agentic system” for a setup where an AI plans and executes actions across steps; and “vision-LM” for a language model that can process images.

What’s disclosed vs what’s not

Topic	Status
Live demo link (X/Twitter)	Provided
High-level explainer	Provided
Model choice (e.g., vision model, planner)	Not disclosed
Latency, reliability, failure modes	Not disclosed
Compute costs and infrastructure	Not disclosed

Why this matters for UK developers and teams

Unlocking the “no-API” estate

UK organisations sit on a mountain of legacy applications – think government, NHS Trusts, local councils, law firms, and SMEs with bespoke systems. Many have no stable APIs and are costly to integrate. If an AI can robustly operate UIs through vision and input, you can automate tasks without rewriting systems.

Augmenting RPA, not replacing it

Classical RPA is great when the UI is stable. It struggles with layout changes, pop-ups, and edge cases. An agent that “sees” the screen could be more resilient, though you’ll trade determinism for adaptability. Expect hybrid patterns: deterministic scripts for the happy path, AI agents for recovery and exceptions.

Compliance and data protection

For UK deployments, questions are immediate:

• Data flow: does screen data leave the device or the UK? That impacts UK GDPR compliance and DPIAs.
• Auditability: can you log decisions, actions, and screen states for audit or incident review?
• Access controls: agents must respect role-based access and least privilege, especially on shared desktops.

Productivity and safety trade-offs

Autonomous control is powerful but brittle. UI updates, dialogue boxes, and unexpected game states (or app states) can break the loop. You’ll need guardrails: timeouts, safe aborts, human-in-the-loop checkpoints, and rapid rollback.

What to ask before you pilot agentic UI control

• Success criteria: what tasks can the agent complete end-to-end, and how often without human help?
• Latency: is the observe-think-act loop fast enough for real-time apps? Not disclosed in the post.
• Safety: how do you prevent misclicks, data entry errors, or destructive actions?
• Observability: are screenshots, actions, and reasoning stored securely for review?
• Cost: per-hour or per-action costs if using hosted models; on-prem options if data is sensitive.
• Change management: who updates prompts, detection templates, and recovery policies when the UI changes?

From games to business software: realistic next steps

If you’re curious to try this pattern, start with a narrow, reversible workflow in a non-production environment. Measure completion rates, time per task, and error recovery. Keep a human on standby for intervention during early runs.

For lighter-weight automation, you don’t need to leap straight to full agentic UI control. Connecting language models to structured tools can deliver quick wins – for example, orchestrating spreadsheets or documents. Here’s a practical walkthrough on wiring a model into everyday tools: How to connect ChatGPT and Google Sheets.

A fun demo with serious implications

The RollerCoaster Tycoon example is playful, but the underlying idea – AI that can see, plan, and reliably click – is a big deal. If the approach proves dependable, it could bridge the gap between modern AI and the legacy applications that run much of the UK economy.

For now, key performance details are not disclosed. Treat the demo as a promising signal, watch for reproducible benchmarks, and, if you experiment, do it safely with clear guardrails and good observability.

Links

• Reddit discussion: AI playing RollerCoaster Tycoon by itself
• Broadcast (X/Twitter): Watch the demo
• Explainer: Ramp Labs – RCT AI