DEV Community: carlosortet

From expensive tokens to intelligent compression: how we optimize LLM costs in production

carlosortet — Thu, 26 Mar 2026 09:24:16 +0000

We spend absurd amounts on AI tokens. And that number is only going up.

At 498Advance we run multiple LLMs in production — Claude for development, Gemini for multimodal, DeepSeek and OpenAI models locally for routine tasks. Every model does something well and fails at something else. That is why they coexist.

But this creates a problem: dependency and cost. What happens when a provider goes down? What happens when pricing changes overnight?

Here is how we deal with it, and why a new Google Research paper caught our attention this week.

Layer 1: Fallback policies

If a model fails, the system automatically redirects to the next available model. No human intervention, no perceptible downtime.

# Simplified fallback logic
models = ["claude-opus", "gpt-4o", "gemini-pro", "deepseek-local"]

def inference(prompt, task_type):
    for model in get_ranked_models(task_type):
        try:
            return call_model(model, prompt)
        except ModelUnavailable:
            log.warning(f"{model} unavailable, falling back")
            continue
    raise AllModelsUnavailable()

Simple but effective. The key is having your models ranked per task type, not globally.

Layer 2: Router shadow

Not every task needs a frontier model. A two-line summary does not need Claude Opus. A 50-page legal analysis does.

Router shadow evaluates each incoming task and routes it to the optimal model based on complexity and cost. We categorize tasks into tiers:

Tier	Task type	Model class	Cost
1	Simple extraction, formatting	Local (DeepSeek 7B)	~$0
2	Summarization, translation	Mid-tier API (Haiku, Flash)	Low
3	Complex analysis, code generation	Frontier (Opus, GPT-4o)	High

The result: cost optimization per project without sacrificing quality where it matters.

Layer 3: Local models

At 498Advance we have been running DeepSeek and OpenAI models locally for three months. They handle a significant portion of production tasks.

The benefits go beyond cost:

Security: data never leaves your infrastructure
Compliance: concrete guarantees about where data is processed
Latency: no network round-trip for simple tasks
Availability: no dependency on external uptime

The trade-off: local models are not frontier models. You lose capability on complex tasks. The strategy is selective migration — identify what can run locally, move it, keep frontier for what needs it.

The compression landscape

At some point, better hardware is not enough. You need efficiency.

LLMs keep growing — tens or hundreds of billions of parameters. The compression techniques that make them deployable:

Quantization reduces weight precision. A quantized Llama 70B fits on 1 NVIDIA A100. Unquantized, it needs 4.

Pruning removes low-relevance weights. 2:4 Sparse Llama achieved 98.4% accuracy recovery on the Open LLM Leaderboard V1, with +30% throughput and -20% latency from sparsity alone.

Knowledge distillation trains a small student model to replicate a large teacher's behavior.

These are not mutually exclusive. Sparsity + quantization yields improvements greater than either alone.

Real-world examples

LinkedIn built domain-adapted EON models on open source LLMs with proprietary data, reducing prompt size by 30%.

Roblox scaled from <50 to ~250 concurrent ML inference pipelines using Ray and vLLM.

Red Hat maintains pre-optimized models on Hugging Face (Llama, Qwen, DeepSeek, Granite) — quantized and ready for inference with vLLM.

TurboQuant: the paper that caught our attention

On March 24, 2026, Google Research published TurboQuant (ICLR 2026). Authors: Amir Zandieh and Vahab Mirrokni.

The headline numbers:

6x minimum KV cache memory reduction
8x speedup with 4-bit quantization on H100 GPUs
3-bit KV cache quantization with zero accuracy loss
No fine-tuning or retraining required

Why it matters technically

Traditional quantization has a memory overhead problem. Most methods need to store quantization constants for each data block, adding 1-2 extra bits per number. TurboQuant eliminates this.

It combines two algorithms:

PolarQuant converts vectors from Cartesian to polar coordinates. Instead of normalizing data on a shifting square grid, it maps to a fixed circular grid where boundaries are known. This eliminates the normalization overhead.

QJL (Quantized Johnson-Lindenstrauss) compresses the residual error from PolarQuant to a single sign bit (+1 or -1) using the JL Transform. Zero memory overhead.

The pipeline:

PolarQuant compresses with most of the bits
QJL uses 1 bit to correct residual bias

Benchmark results

Tested on LongBench, Needle In A Haystack, ZeroSCROLLS, RULER, and L-Eval with Gemma and Mistral:

TurboQuant (KV: 3.5 bits) scores 50.06 on LongBench — identical to Full Cache (KV: 16 bits)
KIVI needs 5 bits for 50.16, drops to 48.50 at 3 bits
Perfect needle-in-haystack results with 6x memory reduction

For vector search, TurboQuant outperforms PQ and RabbiQ in recall ratio even when those baselines use large codebooks and dataset-specific tuning.

What this means in practice

TurboQuant is a research paper, not a product. But the direction is clear:

Same hardware, bigger models: 6x KV cache compression means the GPU running an 8B model could handle something significantly larger
Lower inference costs: 8x attention speedup = fewer GPUs for the same workload
Edge deployment: compression is what separates "interesting demo" from "deployable product"
Simpler compliance: smaller models running locally = less data traveling externally

The race is not for bigger models. It is for models that are smarter about how they use their resources.

OpenAI's Agentic Commerce Protocol: a technical look at how ChatGPT becomes a shopping agent

carlosortet — Wed, 25 Mar 2026 08:51:38 +0000

Last week, OpenAI launched a redesigned shopping experience in ChatGPT. 900 million weekly users can now browse products visually, compare options side-by-side, and get real-time pricing — all inside the conversation.

The protocol powering it is called ACP (Agentic Commerce Protocol), an open standard co-developed by OpenAI and Stripe under Apache 2.0. And the technical implementation is worth a closer look.

What ACP actually is

ACP defines a common language for AI agents and merchants to coordinate transactions. Think of it as an API contract between ChatGPT (the buyer's agent) and a merchant's product catalog.

Key architectural principle: OpenAI is not the merchant of record. Merchants retain full control over products, pricing, payments and fulfillment. ChatGPT is just the conversational intermediary.

The protocol lives on GitHub with 1,300+ stars and 192 forks:
github.com/agentic-commerce-protocol/agentic-commerce-protocol

The pivot nobody expected

OpenAI originally launched ACP in September 2025 with "Instant Checkout" — buy directly inside the chat. Etsy was the first integration.

It didn't work. Out of Shopify's millions of merchants, only about 12 activated checkout. Users browsed and compared, but went to the retailer's site to pay.

OpenAI acknowledged it in March 2026: "the initial version of Instant Checkout did not offer the level of flexibility that we aspire to provide."

The new focus is product discovery: visual browsing, image-based search, comparison tables, budget filtering — then redirect to the merchant's site for checkout.

Technical integration: how it works

Feed specification

Merchants push product data to an OpenAI endpoint via encrypted HTTPS. The feed spec:

Parameter	Value
Formats	CSV, TSV (recommended), XML, JSON
Encoding	UTF-8
Max size	10 GB
Compression	gzip
Update frequency	Every 15 minutes

Required fields per product:

id — unique identifier
title — max 150 chars
description — max 5,000 chars
price — with ISO 4217 currency code
availability — in stock / out of stock / preorder
image_url — at least one high-res image

Recommended: GTIN/UPC/MPN, reviews, rich media, shipping options, performance signals.

Three APIs

Feeds API      → Upload/manage full product catalogs
Products API   → Individual product upserts
Promotions API → Manage promotions (API-only)

For existing Stripe merchants, integration can take as little as one line of code.

Delegated payments

The payment flow uses single-use, time-bound, amount-restricted tokens. OpenAI prepares a delegated payment request; the payment service provider (Stripe, PayPal, Checkout.com) handles tokenization. PCI compliant by design.

Versioning

ACP uses date-based versioning (YYYY-MM-DD). The latest stable spec is 2026-01-30, which added extensions, discounts, and payment handlers.

spec/2025-09-29/  → Initial release
spec/2025-12-12/  → Fulfillment enhancements
spec/2026-01-16/  → Capability negotiation
spec/2026-01-30/  → Extensions, discounts, payment handlers (latest)

ACP vs. Google UCP vs. Amazon

Three ecosystems are forming:

ACP (OpenAI + Stripe): Open standard, Apache 2.0. Feeds update every 15 minutes. 900M weekly users. Focused on conversational product discovery.

UCP (Google): Open standard, launched January 2026. Backed by Shopify, Walmart, Visa, Mastercard. 50 billion indexed products. Covers the full purchase journey.

Amazon (Rufus/Alexa+): Closed ecosystem. 300M Rufus users, 60% higher conversion than standard Amazon flow. Blocks OpenAI crawlers. Removed 600M products from ChatGPT results.

The key difference between ACP and Google Shopping feeds: ACP feeds are designed for AI reasoning, not indexing. Every field can become an argument the agent uses to explain why a product is relevant — not just that it exists.

The data that matters

Agentic traffic converts at 15-30% (Q1 2026 data) — 5-10x over traditional e-commerce
AI-generated recommendations convert 4.4x better than traditional search (McKinsey)
ChatGPT drives 20%+ of referral traffic to Walmart
But: less than 0.2% of total e-commerce sessions come from ChatGPT

The volume is small. The conversion is extraordinary. The year-over-year growth is +805% (Adobe, Black Friday 2025).

What this means if you build e-commerce

If you're building or maintaining e-commerce systems, ACP changes the optimization target.

1. Feed quality > ad spend

Products surface based on what the AI can parse and verify. Incomplete feeds = invisible products. Every missing attribute is a lost recommendation opportunity. A product without a GTIN, without proper category depth (up to 5 levels), or with a generic "Great product, buy now!" description will never be recommended when a user asks for something specific.

2. Descriptions for NLP, not SEO

Attribute-rich descriptions that an AI can reason about beat keyword-stuffed copy. When someone asks "waterproof running shoes for flat feet under $120," the AI needs to find "waterproof," "arch support for flat feet," and the price in your product data. If those attributes are buried in marketing copy instead of structured fields, you lose.

3. Schema markup matters more than ever

Product, Offer, AggregateRating with real data. The AI cross-references your structured data against user queries. Complete schema is no longer optional — it's the foundation of agentic visibility.

4. Multi-protocol support

Prepare to maintain feeds for both ACP (OpenAI) and UCP (Google). Shopify already offers dual support. The formats are similar enough that a single product data pipeline can serve both, but the update frequencies differ (15 minutes for ACP vs. 24 hours default for UCP).

5. Attribution is fundamentally broken

The customer behavior that drives the sale is invisible to existing analytics. A user asks ChatGPT for a recommendation, gets three product suggestions, visits one site, and buys. Your analytics sees a direct visit or an unknown referrer. No impression. No click. No session.

Server-side webhook tracking from ACP/UCP is the path forward. Start building this infrastructure now — you'll need 18-24 months of data before it becomes reliable.

Getting started

Merchant portal: chatgpt.com/merchants
Developer docs: developers.openai.com/commerce
Feed spec: developers.openai.com/commerce/specs/feed
GitHub: github.com/agentic-commerce-protocol
Stripe integration: docs.stripe.com/agentic-commerce

Currently US-only for merchant onboarding. Product discovery is available globally for all ChatGPT users (Free, Go, Plus, Pro).

We wrote a detailed analysis with market data, competitive comparisons, and practical recommendations:
zoopa.es/en/digital-marketing-en/agentic-commerce-protocol-acp-chatgpt-shopping/

What's your take on agentic commerce? Are you already preparing your product feeds for AI agents, or waiting to see how ACP vs. UCP plays out?

robots.txt is a sign, not a fence: 8 technical vectors through which AI still reads your website

carlosortet — Mon, 23 Mar 2026 07:54:14 +0000

You configure robots.txt like this:

User-agent: GPTBot
Disallow: /

User-agent: CCBot
Disallow: /

User-agent: anthropic-ai
Disallow: /

User-agent: PerplexityBot
Disallow: /

User-agent: *
Disallow: /

You enable Cloudflare Bot Management. You set up Akamai. Maybe even a server-side paywall.

And then you query ChatGPT about your product and it cites your website as a source.

How?

I work on GEO (Generative Engine Optimization) projects where we audit how LLMs represent brands. We routinely analyze thousands of prompt-response pairs. Across multiple projects, we consistently find that 10–20% of LLM responses cite the brand's own website as a source — even when every known bot is blocked.

Here are the 8 technical vectors we documented, with academic sources and industry data.

1. Historical crawl data (Common Crawl)

This is the biggest one and the least understood.

Common Crawl is a nonprofit that has been archiving the web since 2007. The numbers:

9.5+ petabytes, 300+ billion documents
~2/3 of the 47 LLMs published between 2019–2023 use it as training data
GPT-3, LLaMA, T5, Red Pajama all trained on it
Google's C4 dataset: 750 GB filtered from Common Crawl

Blocking crawlers today does not retroactively remove content already captured. Those snapshots are permanent, public resources.

Source: ACM FAccT 2024 — "A Critical Analysis of Common Crawl"

2. Client-side paywall bypass

Common Crawl does not execute JavaScript. If your paywall depends on client-side JS:

<!-- Your paywall loads after DOM ready -->
<script>
  document.addEventListener('DOMContentLoaded', () => {
    showPaywall();
  });
</script>

<!-- But the crawler already captured the full HTML -->

The crawler gets the complete article before JS even runs.

Alex Reisner documented this for The Atlantic (Nov 2025): Common Crawl was capturing full articles from NYT, WSJ, The Economist and The Atlantic itself.

3. User-agent spoofing

Some AI bots change their identity when blocked.

Cloudflare documented (Aug 2024) that Perplexity was using:

# Declared user-agent
PerplexityBot/1.0

# What they actually sent
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0

Plus ASN rotation to evade IP-based blocking. The evasion ecosystem includes FlareSolverr (Selenium + undetected-chromedriver), Scrapfly (94–98% bypass rates), and residential proxy rotation.

4. Syndication redistribution

Once your content leaves your domain through any syndication channel, your robots.txt is irrelevant:

Original domain (robots.txt: Disallow)
  → RSS feed (no robots.txt)
  → Apple News (different domain)
  → Email newsletter (archived on web)
  → Cross-posted to social (scraped by bots)
  → API aggregators (reformatted downstream)

Each channel creates a copy outside your control.

5. Web archives (Wayback Machine)

Internet Archive: 1+ billion pages, 99+ petabytes. web.archive.org is domain #187 in Google's C4 dataset.

Harvard's WARC-GPT lets you ingest WARC archives directly into RAG pipelines. As of Feb 2026, publishers like The Guardian and NYT started blocking Wayback Machine over AI concerns.

6. Real-time RAG access

Modern LLMs don't just rely on training data. They fetch content in real time:

Bot	Growth 2024–2025	Mechanism
ChatGPT-User	+2,825%	Fetch on user "search the web"
PerplexityBot	+157,490%	Fetch on every query
Meta-ExternalFetcher	New in 2024	Meta AI features

These bots claim the fetch is "user-initiated" (not autonomous crawling), trying to exempt themselves from robots.txt.

Cloudflare reported Anthropic's bots have crawl-to-refer ratios of 38,000:1 to 70,000:1. For every time they send traffic back, they crawl tens of thousands of times.

Sources: Cloudflare Blog 2025, OpenAI Crawlers Overview

7. Content farms

Content farms — human or AI-operated — rewrite your articles on unrestricted domains:

1. Scrape/copy original article
2. Rewrite to avoid plagiarism detection
3. Publish on domain with no robots.txt restrictions
4. AI crawler indexes the rewrite
5. LLM absorbs the rewritten version

In Bartz v. Anthropic PBC, the court ruled that training AI with content from "pirate sites" constituted fair use. This sets precedent for rewritten content too.

8. Direct non-compliance

The simplest vector: bots just ignore robots.txt.

12.9% of bots ignore it entirely (was 3.3%) — Paul Calvano, Aug 2025
Duke University (2025): "several categories of AI-related crawlers never request robots.txt"
Kim & Bock (ACM IMC 2025): scrapers are less likely to comply with more restrictive directives

The legal status is clear: in Ziff Davis v. OpenAI (2025), the judge described robots.txt as "more like a sign than a fence" — not a technological measure that "effectively controls access" under the DMCA.

The compliance stats

Metric	Value	Source
Bots ignoring robots.txt	12.9%	Paul Calvano, 2025
Top 10K sites with AI bot rules	Only 14%	Market analysis 2025
Sites with any robots.txt	94% (12.2M sites)	Global study 2025

So what do you do?

Blocking alone doesn't work. Defensive measures reduce direct crawling by 40–60% for compliant bots, but they can't touch historical data, syndicated copies, or content farm rewrites.

The alternative is offensive: control the narrative instead of trying to hide from it.

At 498 Advance we built tools for this: GEOdoctor for technical auditing of brand visibility in LLMs, and S.A.M. (Semantic Alignment Machine) for content alignment across owned media, UGC platforms (social GEO) and authority domains.

Full analysis with all academic sources: zoopa.es/en/blog

Have you run into this paradox? Blocking everything but still appearing in LLM outputs? I'd love to hear what you've observed in your own infrastructure.

How I built a proactive personal AI assistant based on Moltbot for 10€ a month

carlosortet — Fri, 30 Jan 2026 07:18:51 +0000

An open source agent with persistent memory, command execution, real proactivity, and WhatsApp as its interface. Full architecture, real costs, and lessons learned.

Why Build Your Own Assistant

The idea of having an AI assistant that actually knows you is nothing new. Anyone who uses ChatGPT, Claude, or Gemini daily has felt the same frustration: every conversation starts from scratch, you have to re-explain your project context, and the assistant cannot do anything beyond the chat window.

At 498AS, we have been experimenting for months with language models applied to real workflows. Not just text generation, but agents that execute tasks, access tools, and maintain long-term context.

When we discovered Clawdbot (Moltbot), we saw an opportunity to close that gap. An open source project that lets you run your own AI agent with persistent memory, command execution, and the ability to message you before you message it.

We set it up. It works. And it costs 10 euros a month.

What Is Clawdbot

Clawdbot (Moltbot) is an open source project that provides the infrastructure for running your own AI agent. It is not a closed product or a subscription app. It is the technical skeleton on which you build your personalized assistant.

Its core capabilities:

Multichannel communication. It talks to you via WhatsApp, Telegram, Discord, or whatever platform you prefer.
Persistent memory. It remembers previous conversations, your projects, your preferences. It does not start from zero.
Command execution. It can run scripts, open applications, control your browser. Real actions on your computer.
Tool and API access. You configure which tools it can use, and the agent integrates them into its responses and actions.
Full control. It runs on your server, under your infrastructure. You decide what data it holds and who can access it.

The key difference from ChatGPT or Claude is that Clawdbot does not live in a third party's cloud. It lives wherever you decide.

Full System Architecture

The Central Server

The heart of the system is a VPS on Hetzner. Minimum specs: 2 vCPUs, 4GB of RAM. Model CX22. Cost: approximately 4 euros per month.

This server runs the Clawdbot gateway, which handles:

Receiving and sending messages
Communication with the AI model
Persistent memory management
Tool and node coordination

The AI Model

Subscription option. If you already pay for Claude Pro Max, ChatGPT Plus/Pro, or similar, Clawdbot can use that subscription directly. No separate API costs.

API option. If you prefer pay-per-use, you can connect the APIs from Claude, OpenAI, or any compatible model. For personal use it typically ranges between 10 and 30 euros per month.

WhatsApp as the Interface

The setup requires a dedicated prepaid SIM. Cost: 6 euros per month with minimal data. The agent has its own phone number. You message it like any other contact and it replies.

Security with Tailscale

The Clawdbot gateway is not exposed to the internet. It only listens on the Tailscale network.

Tailscale is a mesh VPN that creates a private network between your devices. End-to-end encryption, regardless of physical location. Free for personal use.

Our specific configuration:

The Hetzner VPS is on the Tailscale network
Our phones and computers are too
The gateway only accepts connections from Tailscale IP ranges
The firewall is explicitly configured: only Tailscale can reach the gateway

If someone scans the server from the internet, the gateway port does not even show up.

Distributed Nodes

Clawdbot lets you connect "nodes": computers that the agent can control remotely. My MacBook is connected as a node. I can be out on the street, message the agent via WhatsApp saying "open Chrome and look up X" and it does it on my Mac.

All traffic between nodes and the gateway goes through Tailscale.

Access Control

The agent does not talk to just anyone. We have an allowlist of authorized phone numbers. Permissions are granular: who can interact, which commands it can execute, which tools are available, whether execution requires prior approval.

The Proactive Agent: The Real Game Changer

This is the feature that turns a chatbot into an actual assistant. The agent does not wait for you to write. It messages you first.

Email alerts. The agent monitors your email and notifies you via WhatsApp when something relevant arrives.
Calendar reminders. It reads your calendar and alerts you ahead of meetings.
Custom alerts. Weather updates, price monitoring, GitHub repository activity.
Scheduled tasks. "Every Monday at 9, review my pending tasks and tell me what I need to do this week."

Proactivity completely transforms the relationship with the assistant.

Real Cost Breakdown

Item	Monthly Cost
Hetzner CX22 VPS	~4 EUR
Prepaid SIM with data	~6 EUR
Tailscale	0 EUR (free tier)
Total infrastructure	~10 EUR/month

The AI model is separate. If you already have a subscription to Claude Pro, ChatGPT Plus, or similar, you pay nothing extra.

Lessons Learned After Weeks of Use

More useful than expected. What started as a technical experiment became a daily tool.
Proactivity is the differentiator. Having the agent message you when something important happens is a paradigm shift.
Security is non-negotiable. Tailscale, firewall, allowlist, granular permissions. All of it.
WhatsApp as an interface reduces friction. It is where you already are.

How to Get Started

Clawdbot is open source and available on GitHub with comprehensive documentation and an active Discord community.

Get a cheap VPS (Hetzner, DigitalOcean, or similar)
Install Clawdbot following the documentation
Connect WhatsApp with a dedicated SIM
Set up Tailscale on the server and your devices
Define an allowlist of authorized numbers
Configure tools and permissions

Security recommendations:

Do not expose the gateway to the internet. Use Tailscale.
Do not run as root.
Configure user allowlists.
Enable approval for command execution.

We wrote a detailed blog post with the full architecture and step-by-step setup: Read the full article on our blog

Article published by the 498AS team. Questions about the setup? Drop a comment or get in touch.

Clawdbot: The AI Assistant Siri Promised But Never Delivered — Complete 2026 Guide

carlosortet — Sun, 25 Jan 2026 18:32:18 +0000

Clawdbot is an open-source personal AI assistant that radically transforms how we interact with artificial intelligence. Unlike ChatGPT or Claude web, Clawdbot lives inside your everyday messaging apps — WhatsApp, Telegram, Slack, Discord — and can proactively message you, remember conversations from weeks ago, and execute tasks on your computer.

The Problem Clawdbot Solves

For over a decade, big tech companies promised us intelligent assistants that would transform our productivity. Siri arrived in 2011. Google Assistant in 2016. Alexa conquered millions of homes. And yet, in 2026, most users remain frustrated with these tools.

The fundamental problem is that these traditional assistants:

Wait passively for you to speak to them
Forget everything when the session closes
Can't execute complex tasks
Live in closed ecosystems that limit their utility
Prioritize data collection over real functionality

Clawdbot represents a paradigm shift. It's what Siri should have been and never was.

Clawdbot vs Siri vs Google Assistant vs Alexa: 2026 Comparison

Feature	Clawdbot	Siri	Google Assistant	Alexa
Proactivity	Writes to you when there's news	Only responds	Limited to routines	Only basic notifications
Persistent memory	Remembers weeks/months	Forgets on close	Very limited	Session only
Executes PC tasks	Terminal, browser, files	No	No	No
Open source	MIT License, auditable	Closed	Closed	Closed
Your data on your machine	Local-first	Apple servers	Google servers	Amazon servers
WhatsApp integration	Native	No	No	No
Monthly cost	~$27 (VPS+Claude)	Free (with iPhone)	Free	Free (with Echo)

Verdict: Clawdbot is the only assistant that combines real proactivity, persistent memory, and total user control. The trade-off is it requires initial technical setup.

What is Clawdbot and Why Does It Matter

Clawdbot is an open-source personal AI assistant that runs locally on your machine and responds through the messaging apps you already use: WhatsApp, Telegram, Slack, Discord, Signal, iMessage, and 50+ additional integrations.

The fundamental difference with ChatGPT or Claude web is that Clawdbot lives inside your messaging apps. You don't go to a website. You message it like any other contact. And it can:

Proactively send you messages
Remember past conversations
Execute tasks on your computer
Run 24/7

The Local-First Philosophy

One of the most relevant aspects of Clawdbot is its local-first architecture:

Your data stays on your machine by default
No dependency on external servers (except the AI model you choose)
You can audit all the code since it's open-source
You have total control over what it can and cannot do

The Creator: Peter Steinberger

Peter Steinberger (@steipete) is the creator of Clawdbot. He's not an anonymous developer or a weekend project funded by VCs promising to revolutionize the world.

His profile:

Ex-founder of PSPDFKit, a PDF software company with global presence
13+ years of experience in native iOS development
Based in Vienna and London
Builds in public, sharing both successes and failures

Technical Architecture

Clawdbot uses a hub-and-spoke architecture with a centralized Gateway that acts as the control plane. The Gateway manages:

Session routing and isolation: Each conversation stays separate
Channel connections and events: WhatsApp, Telegram, Slack, etc.
Tool execution and streaming: Real-time responses
Canvas/A2UI hosting: Visual interface when needed
Device node orchestration: Multiple synchronized devices

Supported AI Models

Clawdbot isn't tied to a single provider:

Provider	Models	Notes
Anthropic	Claude Pro/Max	Recommended: Claude Opus 4.5
OpenAI	ChatGPT/Codex	GPT-4 available
Local	Ollama, LM Studio	For maximum privacy

Installation and Requirements

System Requirements

Component	Requirement
Node.js	>= 22
Package Manager	npm, pnpm (preferred), or bun
Operating System	macOS, Linux, Windows (via WSL2)
Minimum RAM	2GB (4GB for web automation)
Optional	Docker (for sandboxing)

Quick Installation

npm install -g clawdbot@latest
clawdbot onboard --install-daemon
clawdbot gateway --port 18789 --verbose

Or the one-liner:

curl -fsSL https://clawd.bot/install.sh | bash

Estimated setup time: 30 minutes for basic configuration. 2-4 hours for complete customization with skills.

Differentiating Features

1. Persistent Memory

Unlike traditional chatbots that forget everything when the session closes, Clawdbot maintains continuous 24/7 context, learned user preferences, history of past conversations, and structured memory files. The workspace can be a Git repository — if the bot "learns" something incorrect, you can git revert and return to a previous state.

2. Real Proactivity

This is perhaps the most differentiating feature. Clawdbot doesn't wait passively:

Morning briefings: Summary of emails, calendar, relevant news
Contextual alerts: "Your meeting starts in 20 minutes"
Topic tracking: "That project you mentioned has updates"
Smart reminders: Based on usage patterns

3. System Control

Clawdbot can interact with your computer:

Browser: Automation with Chrome/Chromium (CDP)
Files: Reading and writing
Terminal: Shell command execution
Scripts: On-the-fly creation and execution

4. Extensibility

The skills system allows extending capabilities. Most interesting: Clawdbot can write its own plugins to gain new capabilities.

Real-World Use Cases

Personal Productivity

Automatic Inbox Zero — Email cleanup, mass unsubscription, organization
Smart Calendar — Contextual reminders based on location/time
Flight Check-in — Complete automation without intervention
Morning Briefings — Personalized daily summary

Advanced Automation

WhatsApp Memory Vault — A user automatically transcribed over 1000 voice messages with integrated semantic search.

Grocery Autopilot — From recipe photo to completed shopping cart in under 5 minutes.

Complete Website Migration — @thekitze: "Rebuilt my entire site via Telegram while watching Netflix in bed. Notion to Astro, 18 posts migrated, DNS moved to Cloudflare. Never opened my laptop."

Community Testimonials

"I got up and running today with @clawdbot and it's been nothing short of an iPhone moment for me." — @dajaset

"Using @clawdbot for a week and it genuinely feels like early AGI." — @davekiss

"Not enterprise. Not hosted. Infrastructure you control. This is what personal AI should feel like." — @karpathy

Real Costs

Component	Cost
Basic VPS	~5 EUR/month (Hetzner, 2GB RAM)
Recommended VPS	~10 EUR/month (4GB RAM)
Claude Pro	$20/month
Claude Max	$100-200/month

Minimum functional configuration: ~$27/month (VPS + Claude Pro)

Clawdbot software is 100% free and open-source under MIT license.

Security and Privacy

Clawdbot follows a local-first architecture: your data stays on your machine by default. Being open-source, you can audit all the code. However, the agent has broad access to your system (files, terminal, browser), so you should carefully configure permissions and use Docker containers to limit access in group contexts.

Security Recommendations

Use restrictive pairing
SSH tunneling for remote access
Dedicated number for WhatsApp (ban risk)
Carefully evaluate skill permissions
Run clawdbot doctor regularly

Who is Clawdbot For

Ideal Profiles

Developers — Infinite extensibility, hackable
Technical Power Users — Total control, privacy
Founders/CEOs — 24/7 automation
Content Creators — Multi-platform, community management

Who Should NOT Use It (Yet)

Non-technical users — Requires terminal, VPS knowledge
Companies with strict compliance — Unaudited security
Error intolerant users — Still early stage software

Conclusions

Clawdbot represents a milestone in the evolution of personal AI assistants. It's not perfect — onboarding is still rough, there are occasional bugs, and it requires technical knowledge — but it's genuinely useful in ways Siri never achieved.

For developers and technical power users, it's a transformative tool. For the average user, it's probably better to wait for more polished versions.

What's clear is that the model of "assistant that lives in your infrastructure and contacts you proactively" is the future. Big Tech will eventually arrive. The open-source community got there first.

GitHub: github.com/clawdbot/clawdbot

Analysis by ZOOPA Research | 498AS Innovation Lab | January 2026