LapakPintar - Autonomous Business Operating System for UMKM

LapakPintar gives Indonesia's 65M SMEs their time back. Five auto AI agents monitor prices, analyze sales trends, craft content, reconcile payments, and deliver daily reports; no human ever needed.

Comment

The NexaPaw Story: Reclaiming Time for Indonesia's Unsung Heroes

The Inspiration: The Hidden Cost of Sustaining a Dream

Behind the vibrant storefronts of Indonesia's 65 million Micro, Small, and Medium Enterprises (MSMEs) lies an exhausting, invisible reality. We watched our own family members, neighbors, and local community vendors stay awake until 2:00 AM—not to create new products, but to manually cross-check Shopee and Tokopedia prices, agonizingly reconcile DOKU payments, and write product descriptions while running on empty. The statistics we uncovered validated what we saw at home: the average MSME owner spends roughly 4 hours a day on purely repetitive, operational tasks.

We realized that this loss of time is not just a personal burden; it is a macroeconomic hemorrhage. If we model the national economic bleed over a given time period $T$, where $N$ is the number of MSMEs, $v_i$ is the baseline hourly economic value of owner $i$, and $\tau_i(t)$ is the time wasted on mundane tasks, the impact is staggering:

$$ E_{bleed} = \int_{0}^{T} \sum_{i=1}^{N} v_i \cdot \tau_i(t) dt $$

NexaPaw was born from a singular mission: to reduce $\tau_i(t)$ as close to zero as theoretically possible. We didn't just want to build a software tool for the OpenClaw Agenthon 2026; we wanted to engineer an autonomous digital workforce that could give business owners their time, their sleep, and their lives back.

How We Built It: Orchestrating an Autonomous Symphony

To completely remove the human from the loop of mundane tasks, a single linear script wouldn't suffice. We architected a Multi-Agent System (MAS) utilizing the QwenPaw framework, leveraging the deep reasoning and planning capabilities of the Qwen3-14B large language model.

We divided the operational workload into five distinct, specialized personas, all coordinated by a central Orchestrator connected via a continuous Event Bus:

  • Pantau Agent (The Watcher): Utilizing Playwright and BeautifulSoup4, this agent autonomously scrapes and monitors competitor pricing and market trends across major marketplaces in real-time.
  • Analitik Agent (The Brain): By querying a custom RAG (Retrieval-Augmented Generation) Database of the store's historical data, it uses Qwen3's logical reasoning to detect sales anomalies and forecast demand.
  • Konten Agent (The Marketer): A generative powerhouse that autonomously writes highly optimized product descriptions and schedules promotional content based on the Analitik Agent's insights.
  • Bayar Agent (The Accountant): Our core entry for the Best Payment Use Case. Integrated directly with the DOKU REST API, it handles the complex mathematical lifting of financial reconciliation and automated disbursement.
  • Laporan Agent (The Synthesizer): Aggregates cross-agent insights from our Redis working memory to deliver a single, human-readable daily brief.

The Challenges We Faced: Taming the Digital Chaos

Building a highly autonomous system is akin to conducting an orchestra where the instruments occasionally attempt to play their own sheet music. We encountered several immense technical hurdles:

  1. The Payment Reconciliation Paradox

The most critical challenge was ensuring the Bayar Agent achieved 100% accuracy. Transaction settlements from the DOKU API are rarely straightforward 1:1 matches due to fluctuating platform fees, batch disbursements, and edge-case failure states. We had to implement strict, deterministic mathematical validation constraints within the LLM's prompt to ensure the reconciled state (\Phi) was flawless before allowing any database mutation:

$$ \Phi = \begin{cases} 1, & \text{if } \left| D_{settled} - \sum_{i=1}^{k} (T_i - f(T_i)) \right| \le \epsilon \ 0, & \text{otherwise (Trigger Anomaly Protocol)} \end{cases} $$

(Where D_{settled} is the total batch disbursement, $T_i$ is the individual gross transaction, $f(T_i)$ is the dynamic platform fee function, and $\epsilon$ is the acceptable floating-point tolerance margin).

Teaching a probabilistic LLM to reliably yield to deterministic tools rather than "hallucinating" a successful reconciliation required aggressive prompt engineering, few-shot prompting, and strictly typed QwenPaw tool schemas.

  1. The Scraping Arms Race

Our Pantau Agent initially triggered aggressive anti-bot mechanisms on platforms like Tokopedia. Overcoming this required deep customization of our Playwright implementation. We engineered stochastic, human-like delay functions, dynamically randomized user agents, and implemented robust error-handling pipelines to ensure continuous data streams without violating platform integrity.

  1. Memory State Contamination

Initially, our agents were overwriting each other's context, leading to cognitive drift. We solved this by implementing a dual-layer memory architecture: a volatile working memory via Redis for rapid, ephemeral task hand-offs (e.g., Pantau noticing a price drop \rightarrow Konten generating a flash sale promo), and a Long-Term Memory via a RAG vector database to anchor the agents in overarching business strategies.

What We Learned: The Dawn of Agentic Empathy

The technical evolution of our team was profound. Deploying Qwen3-14B locally via Docker taught us how to optimize inference speeds and manage complex, multi-step reasoning loops without burning through API budgets. We also discovered the immense, untapped potential of the DOKU REST API when utilized not just as a static payment gateway, but as an active, programmatic trigger for automated supply-chain management.

But the most significant takeaway was a deeply human one.

When we ran our first flawless end-to-end simulation—watching the terminal as the system autonomously scraped a competitor's price drop, dynamically adjusted our mock store's pricing, generated a promotional campaign, and perfectly reconciled a batch of mock DOKU transactions—we realized the true impact of our code. We aren't just automating tasks; we are engineering peace of mind. By delegating the cold, mathematical complexities of commerce to AI, we are empowering MSME owners to return to what truly matters: connecting with their communities, innovating their crafts, and finally getting a good night's rest.

Built With

  • beautifulsoup4
  • docker
  • dockercompose
  • dokurestapi
  • fastapi
  • playwright
  • python
  • qwen3
  • qwen3-14b
  • qwenpaw
  • rag
  • ragdatabase
  • rediz
Share this project:

Updates