AI agents hit a wall when they need to interact with legacy Windows desktop applications. No API, no webhooks, no GraphQL endpoint. Just a thick client running on someone’s machine with forms, buttons, and modal dialogs. Minicor (YC P26) builds the plumbing to turn those desktop apps into callable API endpoints using robotic process automation (RPA) at scale.
The problem is not new. Enterprises have thousands of desktop applications that will never get modernized. Electronic health records, dealer management systems, supply chain tools. They run on Windows, they store critical data, and they have zero programmatic interface. When an AI agent needs to read or write data in these systems, the only option is to automate the UI itself.
The Desktop Automation Stack
Minicor’s architecture splits into three layers:
Agent decision layer: Your AI agent decides what action to take (create a patient record, update inventory, pull a report).
Orchestration layer: Minicor translates that intent into a sequence of UI actions (click this button, fill this field, wait for this dialog).
Execution layer: A Windows session runs the automation, captures state, and returns results.
The orchestration layer is where the complexity lives. It handles session isolation, failure recovery, credential management, and observability. The agent calls a REST endpoint. Minicor spins up or reuses a Windows session, executes the automation, and returns structured data.
Session Isolation and State Management
Running multiple automations concurrently on the same Windows machine creates collision risk. Two sessions trying to control the same application instance will corrupt each other’s state. Minicor isolates sessions at the process level.
Each automation runs in its own user session with dedicated application instances. The platform manages session pooling to avoid cold-start overhead. When an automation completes, the session can be reset or persisted depending on whether the next task needs the same logged-in state.
Persistent sessions solve the authentication problem. Many legacy apps require multi-factor authentication, VPN connections, or slow login flows. Minicor vaults credentials and maintains authenticated sessions across multiple automation runs. The agent doesn’t re-authenticate every time it needs to read a record.
Failure Recovery and Verification
Desktop applications crash, hang, or show unexpected dialogs. Minicor’s execution layer monitors process health and UI state at each step. If an expected element doesn’t appear within a timeout window, the automation can retry, escalate to a human, or fail gracefully.
Agentic verification adds a second check. After the automation completes an action (like submitting a form), an AI model inspects the resulting screen state to confirm success. This catches cases where the UI accepted input but the underlying operation failed silently.
Video session replays provide forensic visibility. Every automation run is recorded. When something breaks, you can watch exactly what the bot saw and did.
Scaling Constraints
Desktop RPA doesn’t scale like cloud services. Each automation needs a Windows session, which means a Windows machine. Minicor’s architecture assumes a pool of Windows VMs or physical machines. The orchestration layer routes automation requests to available sessions based on load and session affinity.
| Constraint | Impact | Mitigation |
|---|---|---|
| Session startup time | 5-15 seconds for cold start | Session pooling with keep-alive |
| Concurrent sessions per machine | 10-20 depending on app resource usage | Horizontal scaling across VM pool |
| Application licensing | Some apps limit concurrent instances | License-aware session allocation |
| State persistence | Sessions hold authentication and context | Session affinity routing for multi-step workflows |
Horizontal scaling works, but it’s not elastic in the Kubernetes sense. You can’t spin up 100 new Windows sessions in two seconds. The platform pre-provisions capacity and routes work to available sessions.
Security Boundaries
The agent layer and execution layer are separated by an API boundary. The agent never has direct access to credentials, session state, or the Windows environment. It sends a high-level intent and receives structured output.
Component-level access control restricts what each automation can do. An agent authorized to read patient records might not be allowed to delete them. Minicor enforces these policies at the orchestration layer before any UI action executes.
Human-in-the-loop gating adds approval steps for high-risk actions. The automation pauses, sends a webhook to your system, and waits for confirmation before proceeding. This is critical for financial transactions or data deletion.
Observability and Debugging
Every automation run generates:
- Step-level logs showing each UI action and its outcome
- Screen captures at decision points
- Video replay of the entire session
- Telemetry events pushed to your monitoring stack via webhooks
The logs are structured and queryable. You can filter by automation type, failure mode, or session ID. When an automation fails in production, you have the full context to reproduce and fix it.
Slack integration sends alerts when automations fail or require human approval. The notification includes a link to the session replay and logs.
Code Example: Calling a Desktop Automation
import requests
# Agent decides to create a patient record
patient_data = {
"name": "Sarah Johnson",
"dob": "1985-04-14",
"insurance_provider": "BlueCross",
"policy_number": "BC123456",
"visit_reason": "Annual checkup"
}
# Call Minicor's API endpoint
response = requests.post(
"https://api.minicor.com/automations/ehr-patient-intake",
headers={"Authorization": f"Bearer {api_key}"},
json={"action": "create_patient", "data": patient_data}
)
# Minicor orchestrates the desktop automation
# Returns structured result
result = response.json()
print(f"Patient ID: {result['patient_id']}")
print(f"Session ID: {result['session_id']}")
print(f"Replay URL: {result['replay_url']}")The agent doesn’t know or care that the EHR is a Windows desktop app. It calls an endpoint and gets back structured data.
When Desktop RPA Makes Sense
This infrastructure pattern fits when:
- You need to automate Windows applications with no API
- The application holds critical data that agents must access
- You can provision and manage a pool of Windows machines
- Latency requirements allow for 5-15 second session startup
- You need audit trails and human oversight for sensitive operations
It doesn’t fit when:
- The application has a usable API (use that instead)
- You need sub-second response times
- The desktop app’s UI changes frequently (maintenance cost is high)
- You can’t secure and isolate Windows sessions in your environment
Technical Verdict
Minicor solves the unsexy but critical problem of making legacy desktop apps accessible to AI agents. The architecture is sound: session isolation prevents state collision, persistent sessions avoid re-authentication overhead, and agentic verification catches silent failures.
The scaling model is the main constraint. You’re provisioning Windows VMs, not spinning up containers. Plan capacity ahead of demand. The observability tooling (video replays, structured logs, webhooks) is strong and necessary because desktop automation is inherently fragile.
Use this when you have no other option. If the legacy app has an API, use it. If you can modernize the app, do that. But if you’re stuck with a thick client and need agents to interact with it at scale, Minicor provides the plumbing to make that work reliably.