Code you own, and evidence you can audit
TaskSultan is not a licence you buy and hope to finish adopting. It is a platform you can start on with one process, and keep even if you leave us. This page is for the reader who wants the engineering underneath the offer.
Code-first by design
The Studio and the Robot are views and executors of the code, never a second source of truth. Nothing you build is trapped in a proprietary workflow format.
No lock-in
Automations are readable code that drives web pages through Playwright and Windows desktop applications through UI Automation. If TaskSultan disappears tomorrow, you still own them and you can still run them.
Targets that are proven
A declaration is only trusted once it resolves to exactly one element, and to the intended one, against the live page or desktop window.
Evidence you can audit
Runs produce records, and our own automation estate ships with falsification-grade tests rather than assurances.
A Studio that developers expect
A Monaco-based IDE for editing, running, monitoring and tracing: the workflow your team already knows.
Robot and Orchestrator
A deliberately thin executor for source automations or portable tspkg packages, plus queue, jobs, robots, schedules, credential vault and evidence.
Where TaskSultan fits
- A process you repeat that cannot justify an enterprise RPA licence.
- No UiPath in place, or a small footprint you do not want to grow into a programme.
- A team that wants to automate web, desktop and Excel work this quarter, not next year.
- A buyer who wants to own the automation as portable code, not rent access to it.
Where UiPath fits better
- A large estate that needs central governance, analytics and enterprise support.
- Breadth you cannot build yourself: mainframe, document understanding and AI skills.
- An established RPA centre of excellence with a licence pool already in use.
- Procurement that requires a certified vendor ecosystem.
If that is you, we are not trying to displace it: our builder service develops UiPath automations for teams that need extra firepower, and the UiPath License Optimizer makes the licences you already own go further.
The part closest to your business is the part that never has to change
Pointing an agent at the work and building an automation are not the same shape of thing. Here is the difference, stated as properties rather than preferences.
Two whole planes of platform machinery were added across two versions. The Control plane: jobs, queue, vault, scheduler, robots, dispatch, API, Studio monitor. The Transaction plane: queues, leasing, retries, per-item execution, ingest, API, Studio queues. And the Robot, the part that touches the business system, is byte-identical to v1.1.0.
That is the whole argument in one fact: the part of the system closest to your business process is the part that never has to change when the platform gets better.
The seams, and what each one buys
Staging is a translation contract, not a convention
Runs consume input the platform staged in a declared shape, so an automation is effectively a pure function of staged input. It can be tested hermetically against fixtures instead of live systems, a run can be replayed, and a failure can be reproduced offline.
The Robot never learns about transactions
Queueing, leasing, retries and per-item execution live in the platform, deliberately outside the executor. Automations stay business logic, and reliability arrives as a platform upgrade rather than an automation rewrite.
Engines are platform concerns
One thin Robot executes. Web pages, Windows desktop applications, Excel and files are platform capabilities, as APIs, databases and email will be when they ship. Excel is first-class without Microsoft Excel installed: no licence, no server, no COM plumbing.
There is no second source of truth
The Studio, the workflow view and the Robot are views and executors of the code, never a peer copy of the logic. The UI stays read-oriented, and summaries are derived rather than owned.
Determinism is quarantined to authoring
A brief becomes a deterministic scaffold, and its targets are proven against the live application or window before installation. The model authors; the deployed artifact is pinned code.
Per-item transactional identity
Work is counted as transactions, with business exceptions and system exceptions distinguished, retries bounded, and progress carried in a watermark. A partial failure is a resumable fact rather than a mystery, and re-running does not double-post.
Deployable, verifiable artifacts
Automations ship as portable packages with integrity checking, and credentials come from a vault rather than from the automation's own source. The honest limitation: a package is not self-contained, because it needs the host capability it declares.
What an agent architecture structurally cannot offer
Capability gaps, not criticism: an agent is the right tool for a different job.
| Property | Pointing an agent at the work | TaskSultan |
|---|---|---|
| A seam between what was input and what was done | None: the agent is the input | A staging contract: replayable and hermetically testable |
| A contract at the boundary | Prose in, prose out | Typed capabilities and named refusals |
| Transaction identity | None: a partial failure is guesswork | Per-item execution, bounded retries, a watermark to resume from |
| A reviewable artifact | A prompt and a trace | Code in git, plus an integrity-checked package to deploy |
| Behaviour across upgrades | Changes when the model changes, silently | Pinned: a platform upgrade leaves the Robot untouched |
| Upgrade cost of reliability features | Re-prompt, re-test, hope | A platform change the automations never see |
The honest limitation, since it belongs next to the claims: a deployable package is not self-contained. It needs the host capability it declares, because the estate learned that the hard way and says so in its own architectural record.
How we work with you
One process first
We start where the pain is, not with a platform-wide rollout. One repeated process, on the platform, end to end.
Honest scoping
If your process needs API, Database or Email execution, we say so: those are Phase 2 and we will not pretend otherwise.
Built in the open
You watch the generator produce the automation, and the Studio bind and repair it against the live application or window.
Yours at the end
The code is TypeScript you can take in-house. There is no lock-in step to negotiate later.