Recently I wrote about canvas based workflow automations and how the medium had flipped underneath them. The accessibility argument that defined visual workflow tools for a decade inverted while the category was adapting (or struggling to adapt) to a new reality.
Somewhere closer to code than to nodes is where I left it, and I admit, that wasn't really much of an answer.
Well today I'm beyond proud to pull back the curtain on our answer, and introduce you to Tasks.
A Task is a script
A task is a Python script that runs on Aisle. It can be triggered manually, on a schedule, by a webhook, by an inbound email, by a chat action, or by an API call. It runs on managed compute, has a versioned revision history, and comes with all of the logging & auditing you'd expect from Aisle.
In fact, it comes with everything in Aisle. This is what makes it special.
The script orchestrates the work, and the platform handles everything around the script: the schedule, the credentials, the retries, the prompts, the memory, the integrations, the audit trail. You write the logic; Aisle runs the logic and everything that supports it.
Here is what one looks like:
# Find every open deal at this company. company = aisle.inputs.get("company") deals = aisle.integrations.pipedrive.search_deals( org_name=company, ) # For each deal, grab news since the last run. research = [] for deal in deals: news = aisle.ai.gemini_google_search( f"{company} news since {aisle.run.last_run_at}" ) if news: research.append({"deal": deal, "news": news}) # Hand the lot to a saved prompt to write the brief. brief = aisle.ai.run_prompt( slug="account-brief", research=research, ) aisle.integrations.slack.send_message( channel="#revenue", text=brief, )
That is an entire weekly account briefing automation. No imports or credential plumbing, or segregation of the moving parts; Tasks takes an input, checks Pipedrive, checks Google News via Gemini, sends all of that information to a prompt that prepares an account brief, and sends a Slack message. But I didn't really need to write any of that, as a Task tells you what it does as you read it. This is what we mean by full fidelity. The artifact and the work are the same thing.
The platform underneath
To make Tasks run, we've created the Aisle SDK. This was visible in four places in the above Task:
Prompts are first class citizens
aisle.ai.run_prompt(slug="account-brief", ...). They are the same prompts you use in Chat, Projects etc. Each one is model-agnostic, versioned, logged etc. etc. Tasks call prompts by name. In our example, you (or your colleague) could update the formatting of the Account Brief report without touching the Task; just update the prompt it calls.
Integrations are namespaces
No pip install required, or tokens in code. aisle.integrations.pipedrive uses the credentials stored via your Aisle integration. You can also manage multiple credentials, or even have credentials as a variable input, and scale automations across different team members.
Memory is part of the language
A Task can search, read, write, and update folders of documents with one call. It's the same memory layer chat uses, prompts use, and projects use; Tasks can hydrate shared knowledge bases that your team can RAG across in a Project.
Parallel work is simplified
Concurrency, backoff, rate limiting, and checkpointing are kwargs. You write aisle.parallel(handle, items=rows, concurrency=5, retry=aisle.RetryPolicy(max_attempts=3)) and the platform handles the rest.
Our philosophy here is that a Task should be about logic. Developers should be focused on the work. Everything that isn't that belongs to the runtime.
Why this shape?
The canvas piece argued that a visual graph stops being the shape that helps once a workflow gets real. The reverse is also true. A bare Python script in a Lambda, with credentials in environment variables and prompts hardcoded as strings, isn't the shape either. The script ends up carrying half the platform.
Most automation tooling sits on one of two extremes. Either it hides the logic behind a visual graph that nobody can read at scale, or it gives you the language and makes you build the platform underneath yourself.
The interesting space is the middle. A real programming language for the work, with the platform supplied. The script does the thinking, while the runtime does the operating.
Who is this for?
Honestly, we think that this is ultimately for everyone.
For devs and technical operators stuck maintaining node graphs and edges. Or the inverse: those managing cron hosts, credentials, and inline prompted strings, fighting boilerplate to get a script to do what they want. For both of those people, a Task removes most of the fight.
For builders / AI-native operators: you could write a task today with a model in the loop, faster than you could build it in n8n/zapier/ any other canvas. This is pretty vibe-able. You don't need dev-level python knowledge; just what you want, and the component pieces to get there. Our interface has the SDK baked right in, so it's very easy to pick up.
We're also working on a Task builder agent, using the same SDK underneath. So yeah, basically everyone.
We're very excited about Tasks, and we hope you are too. It's live in Aisle today.