DEV Community: Aniket Maurya

[Boost]

Aniket Maurya — Wed, 04 Feb 2026 12:13:24 +0000

5 Ways to Set Up OpenClaw (aka ClawdBot / MoltBot) — and Actually Use It Day-to-Day

Aniket Maurya ・ Feb 4

#ai #openclaw #tutorial #productivity

5 Ways to Set Up OpenClaw (aka ClawdBot / MoltBot) — and Actually Use It Day-to-Day

Aniket Maurya — Wed, 04 Feb 2026 12:10:58 +0000

Most “setup guides” jump straight into commands. That’s backwards.

This blog will help you get connected to an OpenClaw bot with minimal setup, you can:

respond from phone,
run tasks (code, reminders, web research),
stay secure,
without spending a whole weekend to set it up.

So first: the real problem is choosing the right setup for how you’ll use it.

Below are five practical setups (from easiest to most powerful), each framed around the pain it solves.

1) The “Phone-First” Setup: Telegram DM Bot (fastest time-to-value)

The problem it solves

You want to talk to your agent from anywhere—especially your phone—without opening a laptop, VPN, or SSH app. You also want a clean “inbox-like” experience: quick prompts, quick replies.

Why this setup works

Telegram is lightweight, reliable, and behaves like a “command line for humans.” It’s ideal for:

quick questions (“summarize this”, “draft a message”)
reminders (“remind me at 11am”)
lightweight ops (“check RAM”, “list files”, “run a script”)

What it looks like

You create a Telegram bot (BotFather)
OpenClaw connects to it
You DM your assistant like a person

Best for: personal assistants, founders, solo builders, “run my life from my phone” workflows.

Celesto AI provides a no-setup, no-server solution for humans! Get OpenClaw on your Telegram for free here.

2) The “I Want It Everywhere” Setup: Multi-Channel Bot (Telegram + Discord/Slack)

The problem it solves

Your work happens in communities and team spaces—not just DMs. You want the agent where decisions happen:

Discord communities
Slack team channels
group chats where people collaborate

Why this setup works

A multi-channel setup turns OpenClaw into an “ambient operator”:

answers when mentioned
summarizes threads
drafts responses
keeps notes
can be restricted by allowlists / mention-only behavior

What it looks like

One OpenClaw instance
Multiple channel plugins enabled
Rules like “only respond on @mention” to avoid being spammy

Best for: startup teams, communities, internal “ops bot” usage.

3) The “Automation Brain” Setup: Scheduled Reminders + Cron Jobs

The problem it solves

You don’t need a chatbot. You need a system that remembers.
Following up, applying, sending that DM, doing the weekly check-in—humans drop these constantly.

Why this setup works

OpenClaw can schedule exact-time tasks (one-shot or recurring) that fire without you remembering:

“Tomorrow after noon, remind me to apply”
“Tuesday 10am: send a DM”
“Every weekday at 9:30: give me today’s priorities”

This is where assistants become infrastructure, not conversation.

What it looks like

You tell OpenClaw what/when
It schedules a job (cron)
It pings you at the right moment with context and links

Best for: founders, ADHD-friendly workflows, anyone juggling deals + meetings.

4) The “Coding Agent” Setup: Workspace + Exec (turn it into a real dev assistant)

The problem it solves

You want more than advice—you want actual output:

code changes
scripts run
files edited
repos managed
quick prototypes built

Why this setup works

When OpenClaw has:

a workspace directory
permission to run commands safely …it becomes a practical coding agent that can do the work, not just talk about it.

What it looks like

You point OpenClaw at a workspace (repo or project folder)
It can edit files and run tests/build commands
You review results (diffs, logs, artifacts)

Best for: building product fast, automating repetitive dev tasks, “ship while on your phone.”

5) The “Security-First” Setup: Hard Sandbox (gVisor / MicroVMs / strict mounts)

The problem it solves

If you’re running agents that can execute commands, your threat model changes:

“What if the agent (or a dependency) is compromised?”
“What if a prompt injection tries to exfiltrate secrets?”
“What if a container escape happens?”

Why this setup works

Containers are convenient, but they share the host kernel. If you want serious isolation, you tighten the boundaries:

Common patterns:

gVisor: syscall interception; stronger isolation than vanilla containers with less overhead than full VMs.
MicroVMs (e.g., Firecracker): VM boundary; stronger isolation for “run untrusted stuff” workloads.
Read-only containers + minimal mounts: only mount what’s needed, no host root access, no ambient credentials.
Split duties: keep “internet browsing” separate from “has secrets” workloads.

What it looks like

Run OpenClaw with strict filesystem access (only specific mounted directories)
Use hardened runtime (gVisor / MicroVM) if you’re serious about untrusted execution
Keep keys out of chat logs; use env vars/secrets management

Best for: security-conscious builders, anyone running agents on a machine with real credentials.

Which One Should You Pick?

If you want a simple rule:

Fastest useful: Telegram DM bot (Setup #1)
Team usage: Multi-channel (Setup #2)
Life admin superpower: Cron reminders (Setup #3)
Build products: Workspace + exec (Setup #4)
High-trust environment / real secrets: Security-first sandboxing (Setup #5)

You can also combine them: most serious setups do.

Answer: Resizing image and its bounding box

Aniket Maurya — Sun, 04 Jul 2021 04:57:45 +0000

Jul 4 '21

Another way of doing this is to use CHITRA

image = Chitra(img_path, box, label)
# Chitra can rescale your bounding box automatically based on the new image size.
image.resize_image_with_bbox((224, 224))

print('rescaled bbox:', image.bounding_boxes)
plt.imshow(image.draw_boxes())

https://chitra.readthedocs.io/en/latest/

pip install chitra

</p>

Open Full Answer

Resizing image and bounding box separately can be pain and irritating. CHITRA is an image utility library for Deep Learning that can rescale your bounding box automatically based on the new image size.

📝 Docs: https://chitra.readthedocs.io/en/latest/

Building Machine Learning API with FastAPI

Aniket Maurya — Sat, 22 Aug 2020 05:53:58 +0000

FastAPI is a high-performance asynchronous framework for building APIs in Python.
It provides support for Swagger UI out of the box.

Source code for this blog is available aniketmaurya/tensorflow-fastapi-starter-pack

Lets start with a simple hello-world example

First, we import FastAPI class and create an object app. This class has useful parameters like we can pass the title and description for Swagger UI.

from fastapi import FastAPI
app = FastAPI(title='Hello world', description='This is a hello world example', version='0.0.1')

We define a function and decorate it with @app.get. This means that our API /index supports the GET method. The function defined here is async, FastAPI automatically takes care of async and without async methods by creating a thread pool for the normal def functions and it uses an async event loop for async functions.

@app.get('/index')
async def hello_world():
    return "hello world"

Pydantic support

One of my favorite features offered by FastAPI is Pydantic support. We can define Pydantic models and request-response will be handled by FastAPI for these models.
Let's create a COVID-19 symptom checker API to understand this.

Covid-19 symptom checker API

We create a request body, it is the format in which the client should send the request. It will be used by Swagger UI.

from pydantic import BaseModel

class Symptom(BaseModel):
    fever: bool = False
    dry_cough: bool = False
    tiredness: bool = False
    breathing_problem: bool = False

Let's create a function to assign a risk level based on the inputs.

This is just for learning and should not be used in real life, better consult a doctor.

def get_risk_level(symptom: Symptom):
    if not (symptom.fever or symptom.dry_cough or symptom.tiredness or symptom.breathing_problem):
        return 'Low risk level. THIS IS A DEMO APP'

    if not (symptom.breathing_problem or symptom.dry_cough):
        if symptom.fever:
            return 'moderate risk level. THIS IS A DEMO APP'

    if symptom.breathing_problem:
        return 'High-risk level. THIS IS A DEMO APP'

    return 'THIS IS A DEMO APP'

Let's create the API for checking the symptoms

@app.post('/api/covid-symptom-check')
def check_risk(symptom: Symptom):
    return get_risk_level(symptom)

Image recognition API

We will create an API to classify images, we name it predict/image.
We will use Tensorflow for creating the image classification model.

Tutorial for Image Classification with Tensorflow

We create a function load_model, which will return a MobileNet CNN Model with pre-trained weights i.e. it is already trained to classify 1000 unique categories of images.

import tensorflow as tf

def load_model():
    model = tf.keras.applications.MobileNetV2(weights="imagenet")
    print("Model loaded")
    return model

model = load_model()

We define a predict function that will accept an image and returns the predictions.
We resize the image to 224x224 and normalize the pixel values to be in [-1, 1].

from tensorflow.keras.applications.imagenet_utils import decode_predictions

decode_predictions is used to decode the class name of the predicted object.
Here we will return the top-2 probable class.

def predict(image: Image.Image):

    image = np.asarray(image.resize((224, 224)))[..., :3]
    image = np.expand_dims(image, 0)
    image = image / 127.5 - 1.0

    result = decode_predictions(model.predict(image), 2)[0]

    response = []
    for i, res in enumerate(result):
        resp = {}
        resp["class"] = res[1]
        resp["confidence"] = f"{res[2]*100:0.2f} %"

        response.append(resp)

    return response

Now we will create an API /predict/image which supports file upload. We will filter the file extension to support only jpg, jpeg, and png format of images.

We will use Pillow to load the uploaded image.

def read_imagefile(file) -> Image.Image:
    image = Image.open(BytesIO(file))
    return image

@app.post("/predict/image")
async def predict_api(file: UploadFile = File(...)):
    extension = file.filename.split(".")[-1] in ("jpg", "jpeg", "png")
    if not extension:
        return "Image must be jpg or png format!"
    image = read_imagefile(await file.read())
    prediction = predict(image)

    return prediction

Final code

import uvicorn
from fastapi import FastAPI, File, UploadFile

from application.components import predict, read_imagefile

app = FastAPI()

@app.post("/predict/image")
async def predict_api(file: UploadFile = File(...)):
    extension = file.filename.split(".")[-1] in ("jpg", "jpeg", "png")
    if not extension:
        return "Image must be jpg or png format!"
    image = read_imagefile(await file.read())
    prediction = predict(image)

    return prediction


@app.post("/api/covid-symptom-check")
def check_risk(symptom: Symptom):
    return symptom_check.get_risk_level(symptom)


if __name__ == "__main__":
    uvicorn.run(app, debug=True)

FastAPI documentation is the best place to learn more about core concepts of the framework.

Hope you liked the article.

Feel free to ask your questions in the comments or reach me out personally.

👉 Twitter: https://twitter.com/aniketmaurya

👉 Linkedin: https://linkedin.com/in/aniketmaurya