Wasm size from 30Mb to 300kb and 1.5x speedup. It's definitely worth it for performance or distribution size.

One of the things that bothered me for quite a time is inability of browser agents to work with Routing24.

We have tons of natural tasks for AI:

- data ingestion, to figure out data coming from user's side (csv and Excel);

- geocoding quality validation (to explain user what they need to correct and their addresses and how);

- steep learning curve for business users (who have sense of what they want from route optimization, but setting up the model takes significant time and effort);

- explainability of route optimization decisions (which constraints conflict with each other, why orders are sequenced in a certain way, etc)

- ...

These and many others are very natural tasks for agentic AI in general as well as for desktop business AI assistants (Claude Cowork in particular).

We came up to the realisation when were doing frontend testing from prompts, that used Chrome CDP, where AI instruments and controls the browser.

Our build of Routing24 for integration testing has its state and action model fully exposed to AI tests via `window`, and driving complex test cases from prompts was nice and easy.

Surprisingly, similar reduced state object exposed via `window` to Claude Cowork equipped with `javascript_tool` and browser extension made it possible to drive import, geocoding, optimization and explanation from agent like a charm, the whole app became one large tool+state.

Further it turned our this approach is getting standartized as W3C WebMCP (already in preview in Chrome).

Long story short: Routing24.com free route optimization now works in Claude Cowork and any future WebMCP-compatible agent!

Comments URL: https://news.ycombinator.com/item?id=48786769

Points: 8

# Comments: 0

Why bring server software to edge devices? Because its fucking awesome!

How do you extract and relate to each other the facts from the documents that require comprehension and not simple similarity matching using common embeddings models?

Recently started some agentic features for paid version, and this lead to a side project https://eatmydata.ai - a question-to-sql-to-dashboard builder, where data doesn't get exposed to AI (with bundled in-browser SQLite vector search, NER and many other features).

The latter is open-sourced under MIT: https://github.com/eatmydata-org/eatmydata

We have low-cardinality data and yes this is safe to share and required to build an actual query.

Then we have high-cardinality and possibly PII - there’s absolutely no reason to share that data, there’s nothing for LLM to analyse there. Also semantic index (vector search) will find relevant records much faster and more accurately that any chain-of-thoughts just with an LLM-authored search fn call.

Further there are continuous numerical values and there’s not much LLM needs to see in there either. We can say, for example, if you look at data distributions when building your analysis, it can drive your analysis logic, but another point of view here is taht it creates unnecessary bias instead.

For example, there is no way neither in Claude nor in ChatGPT to run your own WASM or JS or whatever AI produces directly in user's browser context as a tool/skill - there is no call site for that. The only option is remote server-side.

My whole idea was that AI can perfectly write SQL and dashboard code knowing only the shape of your data and not it's contents. With direct upload to vendor now we're forced to share the contents.

For example, MIT-licensed sqlite vector search extension.

Overall, I have a orchestrator - sql coder - js coder - dashboards, all without backend, running locally in the browser. It's mostly tested on small analysis and question answering with Gemini Flash Lite, and the overall target was speed from question to answer, including data sharing and waiting.

https://eatmydata.ai/

https://github.com/eatmydata-org/eatmydata

For the "show me how many people are from Dallas" in AdventureWorks, it really depends on the model.

With `gemini-3.1-flash-lite` for all agents it produces this sql from the first try for $0.0033: ``` SELECT COUNT(DISTINCT ca.CustomerID) as customer_count FROM CustomerAddress ca JOIN ( SELECT a.AddressID FROM vector_search('Address', 'City', 'Dallas', 20) vs JOIN Address a ON a.rowid = vs.rowid WHERE a.City = 'Dallas' ) addr ON ca.AddressID = addr.AddressID ```

and then formats output in Markdown.

I'll bake some default model in later, and more examples. And I guess it needs some default token quota.

You ask a question, agents produce multiple SQL queries to in-browser sqlite, never seeing results, and write dashboard configuration code. The data you analyze will be indexed with a local semantic index (embeddings generation + sqlite vector search fully local).

Next, sandboxed QuickJS runs this code to produce rich dashboards directly in your browser, no backend attached. This is a fully frontend app (except OpenRouter or other remote LLM).

All data sent to LLM's is heavily sanitized and obfuscated at several points. The remote LLM never sees the contents of data it analyzes. Why does it exist - I started this is a testbed for my local-first AI projects, agentic workflows and contextual data analysis experiments.

It grew into a tool I use daily for quick and dirty data analytics when I don't want to waste time debugging SQL or building charts for simple data questions, when I literally need an answer under 10s.

I also don't like the idea of sharing random data in Claude/ChatGPT chat, neither uploading any work-related datasets to them. Plus they both often choke on tiny 100k rows data.

Fully open-sourced under MIT https://github.com/eatmydata-org/eatmydata, run it yourself it's a static web app.

What's in the box:

- SQLite OPFS adapted from wa-sqlite, data queried only locally;

- TurboQuant semantic indexing extension for sqlite (MIT-licensed);

- Quantized PII detection and embedding generation models straight in browser;

- NER and embeddings inference engines in zero-dependency C and wasm-simd128 optimizations (1.7x faster and 38x lighter binary compare to onnxruntime);

- QuickJS sandbox for AI-generated code;

- Orchestrator <-> SQL Planner <-> Coder agent loop that build SQL and dashboards from user query;

- Apache ECharts for dashboards;

- Fork of xslx Community edition to support styles (missing in OSS version upstream).

Hope it'll be useful to anyone who is interested in local-first stuff.

Comments URL: https://news.ycombinator.com/item?id=48472867

Points: 8

# Comments: 2

Multi-threaded WebAssembly in action for route optimization, all bundled with geocoding, OSM maps and routing, and provided world-wide.

We're adding driver's PWA, saving and sharing of route optimization projects, editing of optimized routes, sharing it with others either for execution or for approval, integrations and AI-assisted data imports, auth flows, support prompts, sales automation and all that boring stuff.

It's been approx. an year since we are up and running, and we helped 100+ businesses in the US and world-wide to understand the value and savings of automated route planning, and prepared tens thousands of optimized routes for companies operating from 1 to 50 vehicles. All this keeping our operational expenses low and flat, thanks to our local-first route optimization engine working in the browser, and reliance on OpenStreetMap.