Define, Co-Author, Deploy — Introducing Nen Managed Workflow

Any desktop, any workflow — Nen Managed Workflow combines deterministic actions with vision-language agents to drive predictable, dependable integration outcomes via UI automation.

A tale of two approaches, and the best of both

Robotic Process Automation (RPA) has been the default for desktop automation for over two decades. It records a fixed sequence of clicks and keystrokes through an application's interface and replays it on demand — a dependable way to automate repetitive, high-volume work in systems that were never built to expose an API.

Computer-use Agent (CUA) is the new model. A vision-language model reads the screen and operates it the same way a person does — clicking, typing, and navigating from what it sees — with flexibility to recover workflow independently when interfaces change.

Pure RPA and pure CUA both have difficult trade-offs:

• RPA scripts make desktop tasks repeatable, but hard-coded UI paths are brittle and break when screens change. Low pass rates send teams into perpetual exception-handling turmoil.
• Full computer-vision models are robust to UI changes by design and can self-recover, but they still require supervision and customization to deliver production-grade performance.

Nen draws unique advantages from both models to create agentic UI automation with deterministic gates. We work with customers to author any workflow and deploy automation in hours.

How Nen Managed Workflow works

1. Workflow authoring. Nen co-authors each workflow with the customer, using Nen's Python SDK and a library of pre-built skills (login, navigation, form-fill, extraction, table reading, and more).
2. Desktop connection. Nen's runtime connects to a Nen Computer Use Desktop session to operate target applications through the UI, the same way a human user does. No agent is installed on the customer's systems.
3. Credential security. Application credentials live in the customer's cloud-native secret manager (AWS Secrets Manager, GCP Secret Manager, etc.) and are injected directly into the desktop session. They never enter the agent's context, the model prompt, or the workflow logs.
4. Predictable execution. When a workflow runs, the vision-language model is only invoked where and how the deterministic workflow defines it, and each action step is paired with a deterministic validation that fails loud. When a button doesn't render or a record doesn't post, the workflow immediately halts for human review.
5. Tracing. Each step produces a structured record: screenshot, action taken, model reasoning when used, and outcome. Combined with deterministic validation, Nen Managed Workflows create predictable, auditable business processes stakeholders can stand behind.

Inside a Nen workflow

Nen's Python SDK has four primitives (building blocks) that work together to construct workflows.

• Agent — interprets screen state and executes natural-language instructions against the target application.
• Computer — issues keyboard, mouse, and filesystem actions directly on fixed UI elements. Known buttons, stable forms, predictable menu paths. No model call.
• Secure — manages sensitive credentials so they never enter the desktop environment or the agent's vision context.
• run() — the typed entry point that accepts parameters and returns deterministically validated outputs.

A workflow definition combines these primitives into a Python function that leads to a predictable action with a verifiable success outcome:

from pydantic import BaseModel
from nen import Agent, Computer, Secure

class Params(BaseModel):
    patient_mrn: str

class SecureParams(BaseModel):
    nextgen_username: Secure[str]
    nextgen_password: Secure[str]

class EncounterNote(BaseModel):
    patient_mrn: str
    note_text: str
    signed_by: str

def run(params: Params, secure_params: SecureParams) -> EncounterNote:
    agent = Agent()
    computer = Computer()

    agent.execute("Focus the NextGen username field")
    computer.type(secure_params.nextgen_username)
    computer.press("Tab")
    computer.type(secure_params.nextgen_password)
    computer.press("Return")

    if not agent.verify("Is the NextGen home screen visible after login?"):
        raise RuntimeError("NextGen login failed")

    agent.execute(f"Open the patient chart for MRN {params.patient_mrn}")
    agent.execute("Navigate to the most recent encounter")

    data = agent.extract(
        "Extract the encounter note's MRN, full note text, and signing clinician.",
        schema=EncounterNote.model_json_schema(),
    )
    return EncounterNote(**data)

With Managed Workflows, Nen provides production-tested, deterministic building blocks for workflow authoring — flexible, accurate, painless. Within the building blocks, Nen orchestrates model calls, captures screens, dispatches actions, handles exceptions, produces step-level traces, and more. Customers focus on the workflow. Nen handles the execution plumbing.

What does it mean to be production-ready?

Reliability is the difference between a demo and a revenue-generating workflow. Managed Workflows is engineered for production from the day a workflow is enabled.

We implement reliability in five core design choices.

Model calls contained within deterministic workflow, with validation

The agent never has open-ended control of the desktop. Humans author what actions are performed. Models are only invoked within specific actions. Tools are made available to agents based on actions. Agents act strictly according to prescribed workflows, with independent validations. No unintended actions sneak through.

Failures alert users, with robust auditability

When a step doesn't reach its expected state — a button that didn't render, a record that didn't post — the workflow halts and surfaces the failure for human review, rather than retrying blindly or proceeding with corrupted state.

Every step produces a structured record: screenshot, action taken, model reasoning when used, and outcome. "What did the agent do?" is always answerable from a complete, replayable trace.

Data privacy

Credentials live in the customer's cloud-native secret manager and are injected directly to the desktop login by the runtime — never entering the agent's vision context, the model prompt, or the workflow logs. Per-customer workspaces isolate credentials, traces, and state from every other tenant.

Flexible deployment

Nen provides flexible implementation configurations — on infrastructure, compliance posture, and model choice — to meet customers where they are.

For regulated workloads, the data plane — workflow engine, agent sandbox, and storage — can run inside the customer's own cloud account, with only request metadata held in Nen's control plane.