Launch HN: Coasty (YC S26) – An API for computer-use agents (coasty.ai)

44 points by nkov47 ↗ HN
Hey HN, we’re Nitish and Prateek, the founders of Coasty (https://coasty.ai/computer-use). We’re building computer-use agents that can complete workflows inside legacy desktop software and web applications without usable APIs.

Developers send Coasty a natural-language task either through our consumer app or through our API, select a machine or browser environment, and any relevant credentials or files. The agent then operates the interface through screenshots, mouse, and keyboard input, verifies the result, and returns a structured run record with screenshots, actions, outputs, and errors.

Here is a raw demo of an agent completing a workflow in a legacy application(It’s a mockup): https://drive.google.com/file/d/1ZghU_3vsAYhHVz1bsvE0pkvZYk7...

A lot of important software is still difficult to automate. Healthcare teams submit prior authorizations through payer portals, accounting teams enter data into desktop applications, and operations teams move information between internal systems, spreadsheets, and remote desktops. Many of these applications have no API, incomplete APIs, or integrations that take months to build.

The usual alternative is RPA, record a sequence of clicks and replay it. That works when the interface and workflow are predictable, but it often breaks when a button moves, a pop-up appears, a page loads slowly, or the application enters an unexpected state.

Coasty takes a different approach. The agent observes the current screen, decides what action to take, executes it, and then observes the resulting state before continuing. It does not require DOM access, an accessibility tree, selectors, or an application-specific integration, so the same API can operate browsers, remote desktops, and older Windows applications.

A simplified request looks roughly like this:

  run = coasty.runs.create(
      environment="vm_123",
      task="""
      Open the patient record in the billing portal.
      Enter the attached authorization data.
      Do not submit if the member ID or procedure code does not match.
      Return the confirmation number.
      """,
      files=["authorization.pdf"],
      approval_required=["final_submission"]
  )
The response includes the final status, extracted outputs, a replay URL, and a timestamped event log:

  {
    "status": "completed",
    "output": {
      "confirmation_number": "PA-184392"
    },
    "replay_url": "...",
    "events": [
      {
        "type": "verification",
        "field": "member_id",
        "result": "matched"
      }
    ]
  }
The API can also pause a run for human approval, retry from a checkpoint, or return control to the developer when it encounters a condition the workflow did not anticipate.

We started working on this last summer, because we saw that models were getting better at vision but kept seeing a gap between computer-use demos and the reliability needed for production workflows. Getting an agent to complete a task once is fairly straightforward. Getting it to repeat that task, recover from unexpected states, avoid silently entering incorrect data, and produce evidence of what it did is much harder.

We built several layers around the underlying computer-use model. The system tracks the expected state of the workflow, detects when the application has diverged from that state, and can re-plan instead of continuing blindly. Developers can define invariants such as “the patient name must match the source document” or “never submit without approval,” and the agent checks those conditions during the run.

Each run happens in an isol...

15 comments

[ 16.1 ms ] story [ 259 ms ] thread
How are you all different than the other few CUA APIs in this batch and previous batches?
"Zapier to monitor email inbox and then extract the code" - I hit this exact wall, and ended up building the missing piece myself. The agent gets its own managed address on our domain, and one call blocks until the verification email arrives and it is automatically parsed for OTPs/code/magic link. Available at https://sente.run/
(comment deleted)
The checkpoint and invariant model is a strong fit for these workflows. Having approval gates plus a replayable event log makes the agent's decisions much easier to audit than a simple end-to-end task API.
It's so funny to see YC back tens of generic similar low quality projects
we run screen-driven agents against web forms in production and the failure mode that took us longest to find wasn't navigation, it was commits that don't commit. a react controlled select can render the right value after a click while the framework's internal state never updated, so every pixel says done and the submitted payload says null. vision-only verification passes because the screen genuinely looks correct.

curious how you handle that class without DOM access. screenshot-after-action catches missing UI feedback, but when the UI itself is lying about form state the only reliable tells we found were downstream: the confirmation page, an outbound request, an email arriving. do your verification events ever consume anything besides pixels, or do you lean on the human approval gates for the risky commits?

Congrats on the launch bro.

I use computer-use agents daily as an end user (browser automation, even wireless ADB to install builds on my phone), so genuine question: how does your API handle the diffrence between reversible and ireversible actions ?

Clicking around a page is one thing, but submitting a form, sending a message or confirming a payment is another — is there a mechanism for the agent to pause and hand back to the human before those, or is that left entirely to the caller?

Asking cause in my exp that boundary is where trust in these agents is won or lost.

Founder building document-automation tools for tax firms here — the hardest part is definitely the verification step. For us it's not whether the agent can navigate a UI, but whether the output it produced (a reconciliation report, a tax form) is actually correct when every screen says "success."

We ended up building a secondary rule-based checker that runs independently over the agent's output — it catches things like missing schedules, transposed account numbers, and date mismatches with prior-year filings. The agents handle the execution path, the rules handle the truth.

Curious how you're thinking about this for workflows where a wrong but "successful" action has real downstream cost — do you rely on human review, or do you have a layered verification approach built-in?

That’s exactly the failure mode we’re most worried about. A UI saying “success” is weak evidence that the underlying work is correct.

We’re using a layered approach rather than relying on the computer-use model alone. The execution agent handles navigation, but workflows can also define independent checks against source data and expected invariants,for example, matching patient IDs, totals, dates, procedure codes, or confirming that a record actually changed in the destination system. For higher-risk actions, we can pause before submission or route the completed output to human review.

We’re also trying to keep verification logically separate from execution where possible, so the same agent isn’t simply grading its own work. In some workflows that means deterministic rules; in others it may mean rereading the destination, comparing against the original document, or using a separate model/checker.

Your point about the rules handling truth is a useful way to frame it. I’d be curious how much of your checker is reusable across tax firms versus custom to each firm’s process.

The invariants feature is the most interesting part to me. Are invariants like "patient name must match the source document" enforced deterministically outside the model (a separate checker that gates actions), or does the agent itself evaluate them as part of its loop? Asking because if the same model that decides actions also verifies invariants, a misread screenshot could fail both at once — the check inherits the perception errors it's meant to catch. Curious how you split trusted checks from model judgment.
teknokeras's question maps onto something I hit in a different domain, tool-calling instead of DOM/UI state, so take this as adjacent evidence, not the same bug.

Ran a 63-trial eval on an on-device agent doing calendar/reminders tool calls. The model got its own due date wrong on 89% of calls that needed one, and it wasn't a formatting slip, it computed a genuinely wrong absolute date and called the tool with full confidence. Checked an MLX model as a follow-up and it was worse: 0/36 correct, but every single one was still a well-formed, valid-looking date string. A naive "does this look like a real date" check would've passed all 36.

That's basically teknokeras's failure mode from a different angle. If verification just checks output shape/plausibility instead of an independent ground truth, it inherits whatever the model already got wrong, because the model produced something that looks right by every surface signal available to a shape check. Same reason sneefle's react-state example passes vision verification: looking correct isn't the same claim as being correct.

Fix that held for the date case: don't trust the model for anything derivable independently, resolve it in code from the real system clock, reject anything that doesn't match. Doesn't generalize to every invariant you'd want, but the principle probably does: verification needs a source of truth the model didn't produce.