DEV Community: abokenan444

I Built an Open‑ Source OS for AI Agents – And It’s Ready for You

abokenan444 — Sun, 19 Apr 2026 08:40:48 +0000

Two weeks ago, Web Agent Bridge was a clever middleware that helped AI agents talk to websites without breaking.

Today, it’s a completely different beast.

After a massive rewrite (v2.0 → v3.1), WAB has evolved into a full Agent Operating System – with its own protocol, an open‑core business model, a desktop browser, and even a no‑code workspace for non‑developers.

And yes, it’s still MIT‑licensed at its core.

Let me show you what changed – and why you should care.

🔥 The Problem That Never Died

Every AI agent that needs to click a button or fill a form relies on DOM scraping – CSS selectors, XPath, waiting for elements.
It breaks every time a designer moves a

. It’s slow, fragile, and a nightmare to maintain.

WAB flips the model: websites expose a window.AICommands interface. Agents discover actions (signup, add_to_cart, checkout) and execute them directly. No parsing, no guesswork.

That was v1.0.
Now, v3.1 is something else entirely.

⚙️ What’s New in WAB v3.1 (The “Agent OS” Release)

Agent Operating System (Agent OS)

· Standardised agent‑to‑agent protocol (WABP) with command registry and capability negotiation.
· Complete runtime: event bus, task scheduler, state management, replay engine.
· Built‑in observability – logs, traces, metrics.

Web Agent Protocol (WAP)

· A discovery‑first protocol using /.well-known/agent-tools.json.
· Sites declare their capabilities once, and any agent (MCP, REST, or browser‑based) can understand them.
· WAP is transport‑agnostic – same interface works for CLI, WebSocket, or HTTP.

Open‑Core + Growth Suite

· Core remains MIT (the bridge script, SDK, WAP, and Agent OS runtime).
· Premium features (Fairness Engine, Threat Shield, Dynamic Pricing Shield) are server‑side only.
· First‑class billing, metering, and a marketplace for agent components (15% revenue share).

Agent Workspace (No‑Code UI)

· Drag‑and‑drop interface for regular users.
· Create price‑comparison agents, hotel booking agents, or local‑store finders without a single line of code.
· Full RTL + Arabic support.

WAB Desktop Browser + PWA

· Electron browser with ad blocker (80+ domains), scam shield, fairness ranking, and a built‑in AI agent chat.
· Mobile PWA works offline – install it like any other app.

🧠 Why This Matters for Developers

· You can build agents that actually work.
WABAgent (Puppeteer/Playwright) gives you agent.execute('addToCart', { sku: '...' }) – no selectors, no waits.
· You can extend WAB via plugins.
Dynamic hook system, priority ordering, and audit logging. Build your own pricing shield or custom action pack.
· You can run everything locally.
No cloud required. npx web-agent-bridge start spins up the full Agent OS on your machine.
· You can monetise your work.
The built‑in marketplace lets you sell agent templates, vision models, or automation packs.

🚀 Try It in 30 Seconds

npx web-agent-bridge start

Then open http://localhost:3000 – you’ll see the new Sovereign Dashboard, the Agent Workspace, and the live demo store.

Or download the WAB Browser (desktop) and browse any site with an AI agent in your sidebar.

📦 What’s Still Open Source (MIT)

· window.AICommands bridge script
· Agent SDK (WABAgent for Puppeteer/Playwright)
· WAP protocol + discovery
· React / Vue / Svelte / LangChain packages
· WordPress plugin
· All agent examples and templates

The code you love is still free. The extra muscle (fairness, threat detection, pricing shield, marketplace) is what makes the project sustainable.

👉 I Need Your Feedback

· Does the Agent OS feel like the right abstraction?
· Would you use WAP to make your own site agent‑ready?
· What’s missing before you’d bet your production automation on it?

Star the repo, try the demo, and let me know.
Let’s build the agent‑first web – together.

🔗 GitHub: github.com/abokenan444/web-agent-bridge
🌐 Website: webagentbridge.com
📦 npm: npx web-agent-bridge start

How I made a Tor-based messenger use 400% less battery (without breaking privacy)

abokenan444 — Sun, 15 Mar 2026 11:41:29 +0000

How I Built a Tor-Native Messenger That Uses 400% Less Battery (Without Sacrificing Privacy)

By abokenan444 – Solo developer, privacy advocate, and creator of Shield Messenger

📱 The Problem: Why Most "Private" Messengers Aren't Really Private

When I started Shield Messenger, I asked myself a simple question: Why do even the most secure messengers still leak metadata?

Signal, for example, encrypts your messages beautifully. But their servers still know:

· Who you're talking to (even if they don't know what you're saying)
· When you're talking (timing patterns)
· Your IP address (unless you use a VPN)

I wanted something different. A messenger that treats privacy as architecture, not a feature.

The obvious answer was Tor. But there's a reason most apps don't build directly on Tor: battery life is terrible.

🔋 The Battery Nightmare: Why Tor Kills Your Phone

When you run a Tor hidden service (which is how P2P messaging works), your phone has to maintain several persistent TCP connections to guard nodes. This prevents the operating system from entering deep sleep mode.

On Android, deep sleep is when the CPU shuts down almost entirely, saving massive amounts of power. But with Tor, your phone stays awake, listening for incoming connections 24/7.

The result: A messaging app that drains your battery 10-15% per hour, even when you're not using it.

I measured it. It was unusable for daily communication.

🚫 Why I Rejected Firebase/APNs (The Easy Way Out)

The standard solution to battery drain is to use Firebase Cloud Messaging (FCM) or Apple Push Notification service (APNs) . Instead of keeping a persistent connection, the app sleeps, and Google/Apple's servers wake it up when a message arrives.

But this creates two problems:

Another centralized point of failure – Google or Apple could be forced to block your notifications.
Metadata leakage – Now Google/Apple knows who's messaging you and when.

For a privacy-first messenger, this was unacceptable. I needed a solution that kept 100% of traffic inside the Tor network.

💡 The Solution: Tor Push + Smart Sleep Mode

After months of experimentation, I developed a hybrid approach that I call "Tor Push with Smart Sleep Mode."

Here's how it works:

The Architecture

[Normal Operation]
    │
    ├── User actively chatting → Keep Tor circuits alive, instant delivery
    │
    └── Phone idle (screen off)
         │
         └── Smart Sleep Mode activated
              │
              ├── All non-essential circuits closed
              ├── Keep ONE lightweight guard connection
              ├── Schedule wake-up via AlarmManager every 15 min
              └── Wait for incoming TCP packets to trigger instant wake

Smart Sleep Detection

In the Android app, I monitor user activity:

class PowerManager(private val context: Context) {
    private val powerManager = context.getSystemService(Context.POWER_SERVICE) as android.os.PowerManager

    fun shouldEnterSleepMode(): Boolean {
        // Check if screen is off
        if (powerManager.isInteractive) return false

        // Check if user has been inactive for 5 minutes
        val lastActivity = PreferenceManager.getLastActivityTime(context)
        if (System.currentTimeMillis() - lastActivity < 300_000) return false

        // Check if any voice calls are active
        if (CallManager.hasActiveCall()) return false

        return true
    }
}

Modifying Arti for Sleep Support

The real magic happens in the Rust core. I extended Arti (Tor's Rust implementation) with a new sleep_mode() API:

// In secure-legion-core/src/tor/arti.rs

impl TorClient {
    pub fn set_sleep_mode(&mut self, enabled: bool) -> Result<()> {
        if enabled {
            // Reduce circuit maintenance frequency
            self.circuit_manager.set_maintenance_interval(Duration::from_secs(900)); // 15 min

            // Close all but one guard connection
            self.guard_mgr.set_min_guards(1);

            // Store circuit state for quick recovery
            self.persist_state()?;

            // Tell the runtime to use fewer timers
            self.runtime.set_timer_interval(Duration::from_secs(60));
        } else {
            // Restore normal operation
            self.circuit_manager.set_maintenance_interval(Duration::from_secs(30));
            self.guard_mgr.set_min_guards(3);
            self.restore_state()?;
            self.runtime.set_timer_interval(Duration::from_millis(100));
        }
        Ok(())
    }
}

The Wake-Up Mechanism

The key insight: TCP packets themselves can wake the device. When an incoming message arrives at your .onion address, the kernel receives a packet and can wake the app.

On Android, this requires holding a partial wake lock:

class TorService : Service() {
    private val wakeLock: PowerManager.WakeLock by lazy {
        (getSystemService(Context.POWER_SERVICE) as PowerManager)
            .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Shield:TorWakeLock")
    }

    private val handler = Handler(Looper.getMainLooper())

    // Called when Rust detects incoming traffic
    external fun onIncomingTraffic()

    fun handleIncomingMessage() {
        // Acquire wake lock briefly
        wakeLock.acquire(5000) // 5 seconds max

        // Process message
        processMessage()

        // Return to sleep if no activity
        if (!hasActiveUsers()) {
            handler.postDelayed({ goToSleep() }, 10000)
        }
    }

    private fun goToSleep() {
        // Tell Rust to enter sleep mode
        TorRust.setSleepMode(true)
        wakeLock.release()
    }
}

Scheduled Maintenance with AlarmManager

Even in sleep mode, Tor circuits need occasional maintenance. I use Android's AlarmManager for precise, battery-efficient wake-ups:

class CircuitMaintenanceScheduler(private val context: Context) {
    private val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager

    fun scheduleMaintenance() {
        val intent = Intent(context, MaintenanceReceiver::class.java)
        val pendingIntent = PendingIntent.getBroadcast(
            context, 
            0, 
            intent, 
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

        // Schedule inexact repeating alarm (battery efficient)
        alarmManager.setInexactRepeating(
            AlarmManager.ELAPSED_REALTIME_WAKEUP,
            SystemClock.elapsedRealtime() + AlarmManager.INTERVAL_FIFTEEN_MINUTES,
            AlarmManager.INTERVAL_FIFTEEN_MINUTES,
            pendingIntent
        )
    }
}

class MaintenanceReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        // Wake up Tor for maintenance
        val wakeLock = (context?.getSystemService(Context.POWER_SERVICE) as PowerManager)
            .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Shield:MaintenanceWakeLock")

        wakeLock.acquire(60000) // 1 minute max

        // Tell Rust to perform circuit maintenance
        TorRust.performMaintenance()

        // Release after maintenance
        wakeLock.release()
    }
}

📊 The Results: 400% Battery Improvement

After implementing Smart Sleep Mode, I ran extensive tests on multiple devices:

Scenario Before (Standard Tor) After (Smart Sleep) Improvement
Idle (screen off, 8 hours) 18% battery drain 3% battery drain 500% better
Light usage (5 messages/hour) 12%/hour 2.5%/hour 380% better
Heavy usage (constant chatting) 22%/hour 8%/hour 175% better
Voice call (30 min) 15% drain 12% drain 25% better

Average improvement: ~400% reduction in background battery consumption.

And crucially, message delivery latency remained under 1 second in most cases. When a message arrives, the TCP packet wakes the device instantly.

🎯 Lessons Learned (For Other Tor-Native App Developers)

The 15-Minute Sweet Spot

Android's AlarmManager is optimized for intervals of 15 minutes or more. Anything shorter and you lose the battery benefits of inexact alarms.

Partial Wake Locks Are Your Friend

Never use FULL_WAKE_LOCK – it turns on the screen. PARTIAL_WAKE_LOCK keeps the CPU running but allows the screen to stay off.

Store Circuit State

When going to sleep, serialize your circuit state to disk. If the app is killed, you can restore circuits quickly when waking.

Padding Matters Even in Sleep

To prevent traffic analysis, I send small dummy packets even when sleeping. This maintains consistent traffic patterns and makes it harder to distinguish real messages from maintenance.

🌐 Beyond Battery: What's Next for Shield Messenger

Smart Sleep Mode was just the beginning. Shield Messenger now includes:

· Aethernet integration – When internet is down, it switches to community mesh networks (LibreMesh-based)
· Post-quantum crypto – ML-KEM-1024 + X25519 hybrid key exchange
· Built-in wallet – Real Solana + Zcash support, keys never leave device
· Duress PIN – A fake PIN that wipes everything and shows a decoy database

🤝 How You Can Help

Shield Messenger is open source and looking for contributors:

· Security researchers – Audit the crypto core, find vulnerabilities
· Rust developers – Help improve Arti integration
· Mobile devs – Polish the Android/iOS UI
· Privacy advocates – Spread the word

GitHub repo: github.com/abokenan444/shield-messenger

Join the discussion on Hacker News: https://news.ycombinator.com/threads?id=abokenan444
Web:
https://shieldmessenger.com

Building a truly private messenger is hard. Building one that people can actually use every day without carrying a charger is harder. But I believe it's possible – and I hope Shield Messenger proves it.

– abokenan444, March 2026