Automate any browser task by demonstrating it, not coding it. Verifiable, on-chain.
Joined July 2026
- Tweets151
- Following1
- Followers232
- Likes399
Pinned Tweet
$AEMU is now live.
CA: 7QQSvSuBenaLAUuXZtmSjMbqvupSUhCsTso3f2N9pump
Aemulus is building verifiable browser automation.
Today, automating a browser task means writing brittle scripts full of selectors that break the moment a page changes. And when an automation runs unattended, there is no way to prove what it actually did.
Aemulus solves both.
You demonstrate a task once. Aemulus learns the intent behind it, runs it autonomously on new inputs, repairs itself when a page changes, and seals tamper-evident proof of every step that anyone can independently verify.
The project is fully open source and already includes a hosted platform, a skill marketplace with creator earnings, a TypeScript SDK, an MCP server so any AI agent can run skills and get proof back, a public REST API, and an encrypted credential vault.
Website: aemulusai.com
GitHub: github.com/SeierkDev/Aemulus
Thanks to everyone who has supported the project so far. This is only the beginning.
Phase 4: fork a skill.
The marketplace was read-only in practice. Run what's there, or record your own from nothing, and a skill that was nearly right for your portal was a dead end.
Now you can take a copy. Their plan, your account, yours to edit. Change the selector that doesn't match your site, change the inputs, publish it or don't.
It's a copy, not a link. The original's author can edit, unpublish or abandon their skill and your fork keeps working. What survives is where it came from — so the listing says what it started as, and the original shows what it spawned.
aemulusai.com/market
Phase 3: a skill takes a different path depending on what it finds.
A condition used to ask one thing. Is this element on the page. About one step. Enough to dismiss a cookie banner, not enough for anything real.
Now it asks what the page says: equals, contains, goes above, shows nothing. Same vocabulary a watch rule uses. And one condition covers a group of steps instead of its own, so "if it's already approved, skip these four" is one decision in one place.
Your skill opens the invoice, sees it's already approved, and doesn't pay it twice.
That finishes Phase 3's pipeline work: watches that act, waits, and branches.
Important note.
As we’ve said 100 times before. We don’t control the price. The teams doesn’t own any supply of the token. What we do is just build and give our heart out to our supporters.
It’s understandable that people get mad when price goes down, but this is out of our control.
No with this out of the way, let’s get back to building.
Phase 3 is the deeper intelligence work, and this is part of the third piece: longer pipelines.
You recorded the task on a page that had already loaded, because you only clicked once you could see the thing. Replayed at machine speed the same line arrives early. The table is still spinning, the approval hasn't landed, the total hasn't settled. The step misses its element and the run stops there.
Now a step can wait for it. You pick what it waits for, starts showing a value, stops showing a value, goes above a number, and how long before it gives up.
A timeout either stops the run or carries on, because "the export is still generating" and "the approval never came" are different problems.
Today we're back on Phase 3, and also releasing a showcase video of Recorder v0.1.3 coming later.
Phase 3 is the deeper intelligence work. One piece of it is already in: the generalizer now sees the recording's screenshots alongside the trace, so it can tell two near-identical buttons apart and read what a value actually was, instead of guessing from element names.
Two pieces left.
Zero-knowledge proofs of execution. Runs already carry selective-disclosure receipts, so you can prove one field of a run without showing the rest of it. Next is proving an entire run followed its skill while revealing nothing at all.
Then longer pipelines that branch. A watch can already act instead of only alerting, running the next skill and handing it the value that fired it. What's missing is waits and multi-level conditionals, so a skill can pause for something to happen and take a different path depending on what it finds.
Most of what you do by hand every day has no API.
Your broker's dashboard. The supplier portal your job runs on. The internal tool someone built in 2019 and left. Every automation product starts by asking what it can connect to, and the answer for those is nothing.
Aemulus starts somewhere else. You do the task once in your own browser, already logged in, and it watches. What you did becomes a skill, with the parts that change pulled out as inputs. Next time you hand it a different date or a different wallet and it does the same job.
Nothing to integrate, no keys to request, no waiting on anyone's roadmap to automate your own work.
Aemulus Recorder v0.1.3 is uploaded to the Chrome Web Store, waiting on review.
What's new since 0.1.2.
Watches that act. A watch checks one value on a page on a schedule. Before, it could only tell you that value moved. Now it runs another skill the second the rule fires, and hands that skill the value that fired it. Price drops below your number, the buy skill runs.
And the popup now asks when you care, right next to the name, at the moment you click the value: goes below, goes above, stops containing, starts showing a value. Before, you set that later on the site. Now it travels with the capture and is already filled in when you set the watch up.
Showcase video of this going up tomorrow aswell😎
One thing for developers.
There's an MCP server. Point your agent at it and every skill you've recorded becomes a tool it can call.
That means your agent stops being stuck outside logins. It can pull the number off your exchange account, read a dashboard nobody built an API for, submit the form on the internal tool at work. Because the skill replays in a real browser with a real session, not through an integration someone had to write first.
You record the task once. Your agent can do it from then on.
aemulusai.com/developers
Vision-grounded synthesis from phase 3 live in Aemulus.
When you record a task, the generalizer turns it into a skill. Until now it worked from the trace alone. The clicks, the selectors, the text of what you touched. On a site whose markup is generated garbage that means reading div > div > span and guessing.
Now it sees the page. A few frames from your recording go with the trace, so it can tell which of five identical buttons was the submit and read what a value actually was.
Better skills out of the same recording, and fewer that break later.
aemulusai.com
Worth spelling out what actually changes here.
Every automation tool you've used works on sites somebody integrated first. Zapier has a list. Trading terminals have a list. If your page isn't on it, you're refreshing by hand forever.
This has no list. You record the page yourself, set the rule yourself, and choose what happens when it's true. A minute of work, on any page you can open. Including the ones only you can see.
That's the gap between being told something happened and being there when it does. Claim window, allocation, restock, an invoice landing. Same machinery, no integration, no waiting for someone to support your site.
The recorder stops being a way to save clicks. It becomes something that watches and acts while you're asleep.
Introducing the Aemulus Recorder v0.1.3.
Right now a watch tells you a value changed. That's fine for a dashboard and useless for a trade.
In v0.1.3 you set the rule while you're recording. Click the number, then say when you care. Below this, above that, moved more than 5%, this text appeared. Not "the dev's holding changed", but "the dev's holding dropped under 5%".
And then the part that matters: it doesn't just message you. It can run the next skill. Claim page goes live, it claims. Allocation appears, it fills the form. Dev dumps, your exit runs.
Same thing outside crypto. In stock, add to cart. Status says shipped, update the sheet.
Soon on the Chrome Web Store.
Introducing the Aemulus Recorder v0.1.3.
Right now a watch tells you a value changed. That's fine for a dashboard and useless for a trade.
In v0.1.3 you set the rule while you're recording. Click the number, then say when you care. Below this, above that, moved more than 5%, this text appeared. Not "the dev's holding changed", but "the dev's holding dropped under 5%".
And then the part that matters: it doesn't just message you. It can run the next skill. Claim page goes live, it claims. Allocation appears, it fills the form. Dev dumps, your exit runs.
Same thing outside crypto. In stock, add to cart. Status says shipped, update the sheet.
Soon on the Chrome Web Store.
Think about what this looks like when it's normal.
Everyone has a handful of things they check by hand every day. Nobody automates them, because automating costs more time than just doing them. That's been true for as long as there have been computers.
The second teaching one takes sixty seconds, it stops being true. And every one of those little jobs becomes a skill someone publishes and everyone else can run.
That's what's being built here. Not a bot. A place where the work people do by hand gets done once and shared, with proof attached.
We're at the start of it.
Phase 2 is closed. Phase 3 is open. Deeper intelligence.
Three lines in it, and each one stands on something that already runs today.
The model sees the page. Right now a skill is built from the trace. What you clicked and typed. Next it sees the page itself, so a skill survives a redesign that breaks anything selector-based.
Prove the whole run. Today you can prove one field from a run without revealing the rest. Next you prove an entire run followed its skill without revealing the run at all.
Skills that decide. Today a skill can call another and hand its outputs along. Next come waits and conditionals. A pipeline that branches instead of repeating.
Deeper, not wider.
aemulusai.com/roadmap
