Sorting and routing
Read what came in, decide which bucket it belongs to, put it there. Low risk, easy to check, and wrong answers are visible immediately.
How-to — — by Mahmoud Zalt
You can Build a Custom AI Employee with no code, and here is exactly how far that gets you, where it stops, and what to do when it stops.
You do not want to learn Python. You want the follow up emails sent, the spreadsheet updated, the messages sorted, and you want it to keep happening while you do the work you are actually paid for.
That is a completely reasonable position, and the no code path is genuinely open now in a way it was not two years ago. It just comes with a shape, and the shape is worth knowing before you spend a weekend on it.
A no code builder gives you the same pieces a developer wires by hand, just drawn as boxes. A trigger box starts the work, a model box makes the decision, app boxes do the actions, and lines between them carry the result along. What you gain in speed you give back in what happens off the happy path.
There is a third option that people often miss, which sits between a builder and a developer. With Sistava you do not draw the boxes at all. You write the job down the way you would explain it to a new starter, connect the accounts it should touch, and hire an AI Employee that already knows how to retry, how to ask before it does something risky, and how to keep a record you can read.
Anything that reads from a place you already have, decides one thing, and writes to a place you already have. Sorting inbound messages, drafting replies for review, filling a spreadsheet from forms, summarising documents into a folder, chasing a list on a schedule. If the job fits that shape, no code will finish it.
The tell is whether every input arrives in a similar form. Forty quote requests that all come through the same form are a great fit. Forty requests that arrive by email, phone note, text message and a scribble on a delivery slip are not, because the agent spends all its energy on the reading and none on the deciding.
Read what came in, decide which bucket it belongs to, put it there. Low risk, easy to check, and wrong answers are visible immediately.
Write the reply, the post, the summary, but leave it as a draft. You keep the final click, which removes almost all of the risk.
Take a form, a receipt or a transcript and turn it into structured rows. Repetitive, checkable, and genuinely tedious for a person.
A weekly sweep of anything that has gone quiet, with a nudge sent or flagged. Simple logic, real time saved.
Check a source, notice what changed, tell you in one message. Reads only, so the worst case is a boring message.
Convert, rename, tag, file. Nobody enjoys it, the rules are clear, and mistakes cost seconds not customers.
It stops at failure, permissions and change. Builders are excellent at describing what should happen. They are much weaker at describing what should happen when a step does not work, who is allowed to approve what, and how the whole thing keeps up when your process shifts in March.
This matters more than it sounds. The failure path is where money gets spent twice, customers get messaged twice, and records get overwritten. In a drawing, that path is an unlabelled arrow going off the side of the canvas.
The second limit is permissions. Most builders connect to an app with one account, and that account tends to have far more access than the job needs. An agent that only needs to read invoices should not be holding a key that can also delete them, and in a drawing that distinction is invisible.
The third is drift. A field gets renamed, a form gets a new question, an account expires. The workflow keeps running and quietly produces slightly wrong output, and nobody notices for eleven days because nothing errored. That is the single most common way a no code agent lets people down.
Tomas runs a two person window cleaning company. About forty people a month request a quote through his website form, and he was losing roughly a third of them simply because he replied three days late from a van.
His no code agent took an evening. Form comes in, model reads the address and the job description, matches it against his rate table, drafts a quote email, and puts it in his drafts folder. He reviews and sends from his phone between jobs. Nothing gets sent without him, which is why the risk was low enough to try.
Tomas still runs that workflow, and it still saves him real money. His summary is the fair one: the building was an evening, the babysitting is forever, and it is worth it because the job is small enough that a mistake costs one awkward email.
Follow that order and your first agent will be modest and boring, which is exactly right. The agents that cause problems are the ambitious ones built by people who have not yet watched one fail in a way they did not predict.
| Dimension | Traditional | With Sista |
|---|---|---|
| Time to first version | An evening for a simple job | Minutes, because the wiring already exists |
| What you describe | Every box, every arrow, every branch | The job, in the words you would use with a person |
| When a step fails | You design the retry, or there is none | Retries, backs off, and tells you when it gives up |
| Approval before risky actions | You have to build the pause yourself | Built in, per action, before anything leaves |
| Seeing what happened | Run history, if the tool keeps it | A readable record of every decision and cost |
| When your process changes | Redraw the boxes and hope nothing else broke | Tell it what changed, the way you would tell a colleague |
It will not carry a job that runs over days without losing the thread. Give an agent a task that spans a week and it will repeat steps, work from a plan that stopped being true on Tuesday, and sound confident about both. That is a property of the technology, not of your builder.
It will not read a room, decide what deserves your attention this month, or chase a person who is ignoring you until they respond. It cannot sign anything that needs an accountable human, and it cannot do anything physical. Those edges do not move with a better tool, and honest tools tell you so.
Yes, for jobs that read from one place, decide one thing and write to another. Visual builders and hiring platforms both get you there without code. What still needs thought, code or not, is what happens when a step fails, which accounts the agent is allowed to touch, and how you find out when it quietly stops working.
A workflow follows the path you drew, every time. An agent decides which step comes next based on what it finds, which is why it can handle inputs you did not anticipate and also why it can surprise you. Most no code tools now blend the two, with a model making decisions inside a drawn structure.
It depends on the tool. Some builders ask you to bring your own model key and bill you for the tool separately, so you get two bills and full control of spend. Others include the model in their plan, which is simpler and usually has usage limits. Check which one you are choosing before you rely on it, because it changes how a runaway run costs you.
It is safe in proportion to the access you grant. Connect only the apps the job needs, choose read only where you can, and prefer a setup that drafts rather than sends for the first month. Treat an agent connection like a new staff member's login, because that is exactly what it is.
Whatever you designed, which for most first builds means nothing at all. It stops, or worse, it keeps going with bad data and produces plausible wrong output. Add two alerts before you go live: one when a run fails, and one when a whole day passes with no runs, because silence is the failure people notice last.
When the job starts touching money, customers or records you cannot easily undo, or when you find yourself rebuilding the same drawing every time your process changes. At that point you are doing the maintenance work of a platform without the platform, and either hiring a ready AI Employee or getting a developer involved will cost you less.
The no code path is real and it is worth taking. Just take it with your eyes open: an evening to build, an ongoing habit to keep it healthy, and one job at a time so that when something goes wrong you can tell which thing it was.
Start with a job where the worst outcome is an awkward email. Get a month of real output under your belt. Then decide whether to build the next one yourself, or hand the whole category to something that already knows how to fail politely.