Logo

Arachne

Inspiration

We started with a simple question:

What if you could text an AI and have it use the web for you?

Instead of opening a browser or downloading another app, you could simply message Arachne through iMessage to search for products, research questions, check websites, or complete web tasks.

We built the first version around autonomous browser control. But we quickly ran into the reality of modern websites: authentication, 2FA, anti-bot systems, and difficult mobile interfaces made reliable authenticated automation extremely difficult.

That led us to rethink what messaging is actually good at.

A text arrives when something happens.

So instead of constantly asking Arachne to check something, why not tell it what to watch—and let it come back to you?

Arachne became a persistent AI web watchdog.

What it does

You text Arachne what you want to know or keep an eye on, and it handles the rest.

One-time research

Ask questions in plain English:

"Find me a mechanical keyboard under $100."

"Research the best options for this product."

"What's the weather today, and should I bring a jacket?"

Arachne searches the web, extracts relevant information, reasons over it, and sends the answer back through iMessage.

You can even send it a photo of something, and Arachne can identify it and search for it.

Persistent monitoring

You can also tell Arachne to watch something:

"Tell me if one goes under $80."

"Tell me when university applications open."

"Track this stock every 15 minutes."

"Remind me 3 days before the deadline."

Arachne checks automatically and only messages you when something meaningful happens.

It supports several kinds of watches, including:

Price / numeric changes — "tell me when it's under $80"
State changes — "tell me when it's back in stock"
New appearances — "tell me when this goes on sale"
Deadlines — "remind me before applications close"
Scheduled digests — "send me the weather every morning"

You can manage everything conversationally:

"What am I watching?"

"Change the threshold to $70."

"Check it now."

"Stop watching the keyboard."

Why Arachne?

The key idea is that Arachne isn't just another chatbot that gives you an answer and disappears.

It persists.

Traditional AI agents are generally designed around individual sessions. Arachne is designed around tasks that continue running in the background.

It combines:

LLM reasoning to understand natural-language requests
Web research to gather information
Deterministic code to reliably detect meaningful changes
Persistent storage so watches survive restarts
Scheduling so tasks run without another message from the user

The model extracts facts from the web, while deterministic code decides whether those facts actually satisfy the user's alert condition. This makes monitoring more reliable and avoids repeatedly asking an LLM whether it should send an alert.

How We Built It

Arachne connects messaging, AI, and web infrastructure:

Linq API — connects Arachne to iMessage and handles incoming/outgoing messages and images.
OpenAI — understands natural-language requests and reasons over research results.
Browserbase — provides web search and cloud browser infrastructure.
Stagehand — enables natural-language browser automation for websites that require interaction.
Node.js / Express — coordinates the backend and asynchronous tasks.
SQLite — stores persistent watches and their state.
Scheduler — continuously checks for watches that are due.

To keep monitoring fast and inexpensive, Arachne uses a tiered research system. Simple pages are handled through direct HTTP requests or fast web search, while full browser automation is only launched when a site actually requires it.

Challenges We Ran Into

Pivoting from browser automation

Our original vision depended heavily on authenticated browser automation. Real-world login flows quickly showed us that this wasn't reliable enough to build around.

Rather than continuing to fight the problem, we changed the product around a use case that messaging was naturally suited for: proactive notifications.

Detecting changes instead of repeating states

A watch for "under $80" shouldn't message you every minute while something remains at $75.

Arachne therefore tracks previous observations and alerts on meaningful transitions, rather than simply checking whether a condition is currently true.

Separating extraction from reasoning

We learned that extracting information from a webpage and answering a user's question are two different problems.

Arachne first gathers structured facts from the page, then uses the model to reason over those facts and produce the actual answer.

This makes the system both more reliable and easier to test.

What We're Proud Of

Persistent autonomous monitoring that continues without the user having to ask again.
200+ automated tests covering alert logic and failure cases.
Durable watches that survive server restarts.
Multi-tier web research that avoids launching expensive browser sessions when they aren't necessary.
Natural-language control for both creating and managing watches.
Honest failure handling instead of pretending information was found when it wasn't.

What We Learned

The biggest lesson was that the best product isn't always the one we started building.

We originally wanted Arachne to be an AI that could operate the entire web for you. Building it taught us that authentication and modern anti-bot systems make that difficult to do reliably.

But that limitation led us to something more interesting:

Instead of making the user repeatedly interact with the web, let the AI keep watching it for them.

We also learned to let each component do what it does best: the model understands language and extracts information; code handles deterministic logic and persistence.

What's Next

We're still working toward the broader vision of Arachne as a conversational interface to the web.

Future directions include:

Better source selection for difficult research questions
Adaptive watch frequencies based on how often information changes
Multi-source monitoring and cross-checking
Comparative digests that analyze trends across multiple checks
Authenticated sessions for personalized web tasks
Confirmation-based actions, such as asking for approval before making a booking
Voice messages as an alternative to typing
Group chat support for teams and families

Ultimately, we want Arachne to make the web feel less like a collection of websites you constantly have to visit and more like something that comes to you when it matters.