This is a submission for the OpenClaw Challenge.
What I Built
There's a particular kind of friction that's hard to name but easy to feel. Someone drops a message in Discord — "hey, can someone track this bug?" — and you know exactly what happens next. You open a new tab, navigate to your project board, create the task, copy the link, paste it back into the chat. By the time you're done, the conversation has moved two topics ahead and the context is already gone.
I built ManageMe because I kept losing that context.
ManageMe is a workspace and task management system where your chat app is the interface. No slash commands to memorize. No rigid syntax. You talk to it the way you'd talk to a teammate — and it figures out what you mean.
Say "remind me to fix the login bug tomorrow" and a task gets created with a due date. Say "that payment issue is done" and the status updates. Say "who's working on the API refactor?" and it tells you. The web dashboard exists and stays in sync, but you can go days without opening it.
OpenClaw is what makes all of this possible, and it's the part of this project I'm most excited to talk about.
Demo
Watch the full demo on YouTube
The demo covers: creating tasks through natural conversation, uploading a file attachment, updating task status, and watching the web dashboard sync in real time — without ever leaving Discord.
What Actual Interactions Look Like
The best natural language interfaces feel boring to describe, because the interaction is just... talking.
"can someone track the auth bug from earlier"
→ Task created: "Auth bug from earlier" — added to active workspace
"mark the auth bug as in progress, I'm picking it up"
→ Status updated: Auth bug → In Progress, assignee set
"attach this screenshot to it"
→ File uploaded and linked to the task
"what's still open from this sprint?"
→ Lists open tasks with statuses and assignees
No command to remember. No manual trip to Jira. The conversation that created the work is also the interface for tracking it.
How OpenClaw Makes This Work
This is worth spending real time on, because OpenClaw changes the design conversation in a way that isn't obvious until you've built with it.
The conventional approach to chat integrations: write a Discord bot. That bot has its own webhook handler, its own command parser, its own auth flow. It speaks Discord. If you want Telegram too, you write another bot that speaks Telegram. Two codebases, same logic, permanent synchronization debt.
OpenClaw inverts this. You write a skill — a self-contained module that handles a specific domain of intent — and the gateway takes care of routing it from and to whatever channels are configured. The skill doesn't know or care whether the message came from Discord or Telegram. It just receives structured intent and returns a response.
For ManageMe, the skill handles everything task-related: creation, updates, queries, file attachments, workspace switching. OpenClaw validates the incoming request (HMAC signature, rate limits, channel permissions), routes it to the skill, and forwards the response back to wherever the message originated.
What this means in practice: I added Telegram support in about fifteen minutes. Changed the config, restarted the gateway, done. The skill didn't change at all.
{
"skills": {
"entries": {
"manageme": {
"env": {
"MANAGEME_API_URL": "http://localhost:3000",
"MANAGEME_OPENCLAW_SECRET": "your-secret",
"MANAGEME_WORKSPACE_ID": "your-workspace-id"
},
}
}
}
}
OpenClaw's routing layer handles distinguishing messages addressed to ManageMe from general chat noise. The intent parsing lives inside the skill and uses context from the conversation to figure out what action, if any, is being requested.
The other thing worth noting: the gateway runs locally. No managed service sitting between your team's messages and your API. Every request is inspectable, failures are debuggable, and there's no pricing model that changes as usage grows. For infrastructure that every conversation about work flows through, owning it is worth the setup cost.
Architecture
Three layers: OpenClaw handling multi-channel routing and intent delivery, a Hono/Next.js backend managing business logic, and a React dashboard that stays in sync via Appwrite's real-time subscriptions.
Discord / Telegram / Slack
│ natural language messages
▼
┌──────────────────────────────────┐
│ OpenClaw Gateway │ HMAC validation, rate limiting,
│ │ channel routing, noise filtering
│ ┌──────────────────────────┐ │
│ │ ManageMe Skill │ │ Intent parsing, entity extraction,
│ │ (natural language NLU) │ │ action dispatch
│ └──────────────────────────┘ │
└──────────────┬───────────────────┘
│ structured API calls
▼
┌──────────────────────────────────┐
│ Hono API (Next.js 14) │ Type-safe routes, Zod validation,
│ │ task / file / workspace services
└──────────────┬───────────────────┘
│
▼
┌──────────────────────────────────┐
│ Appwrite │ Database, file storage,
│ │ real-time subscriptions
└──────────────┬───────────────────┘
│ real-time events
▼
┌──────────────────────────────────┐
│ React Dashboard │ TanStack Query, Radix UI,
│ │ optimistic updates
└──────────────────────────────────┘
From Message to Task — the Full Pipeline
When someone says "can you add a task for fixing the checkout flow":
- Discord sends the message to the OpenClaw gateway
- Gateway checks the HMAC signature and rate limit (5 req/min per channel)
- Gateway routes to the ManageMe skill
- Skill runs intent recognition — action:
create, entity:task, title:"Fix checkout flow" - Zod validates the extracted parameters against the task creation schema
- Hono handler calls the task service, writes to Appwrite
- Appwrite fires a real-time event to all subscribed clients
- React dashboard updates via React Query cache invalidation
- Gateway sends the formatted confirmation embed back to Discord
End to end: 150–300ms. The user sees a response before they've looked back up at the screen.
Technical Stack
Backend
- Next.js 14 (App Router)
- Hono — type-safe API routes with automatic TypeScript inference
- Zod — runtime validation at every API boundary
- Appwrite — database, file storage, real-time subscriptions
- OpenClaw — multi-channel gateway, natural language routing, skill architecture
Frontend
- React 18
- Tailwind CSS
- Radix UI — accessible component primitives
- TanStack Query — optimistic updates, cache management, background sync
What makes the stack coherent: Hono plus Zod gives you end-to-end type safety without generated code. Define the schema once, get full TypeScript inference from the API handler down to the React component calling it. Three bugs that would have been production incidents — a mismatched field name, a missing required parameter, a date serialization error — were caught at compile time instead.
Code Highlights
Type-Safe API Route
const createTaskSchema = z.object({
title: z.string().min(1),
dueDate: z.coerce.date().optional(),
assignee: z.string().optional(),
workspaceId: z.string(),
});
app.post("/tasks", zValidator("json", createTaskSchema), async (c) => {
const data = c.req.valid("json"); // fully typed — no casting needed
const task = await taskService.create(data);
return c.json({ success: true, task });
});
Real-Time Sync with Optimistic Updates
const { mutate } = useCreateTask();
mutate(
{ title: extractedTitle, workspaceId: workspace.id },
{
onSuccess: () => {
queryClient.invalidateQueries(["tasks", workspace.id]);
},
onError: () => {
queryClient.cancelQueries(["tasks"]);
// optimistic update rolls back automatically
},
}
);
What I Learned Building This
Natural language is a UX decision, not just a technical one. The temptation when building a chat integration is to make the syntax strict — /create task [title] --due [date] — because it's easier to parse. But strict syntax puts the cognitive load on the user. They have to remember the format every time. Natural language flips the load: the system does the work of figuring out what you mean, and the user just talks. Getting the intent parsing reliable enough to trust took iteration. The payoff is that the interface disappears. That's what you want from a tool.
OpenClaw's architecture changes how you think about integrations. I went in expecting to write a Discord bot and bolt on OpenClaw as a routing layer. What actually happened was that I stopped thinking about platforms entirely. The skill is the product. Discord, Telegram, Slack — those are delivery mechanisms. Once that mental model clicked, the whole architecture got simpler. Adding a new channel became a config change, not a development project.
Type safety compounds. Three production bugs were caught at compile time because types flowed end-to-end through Hono and Zod. That's not a coincidence — it's what happens when you eliminate the gap between "what the API expects" and "what the frontend sends." The confidence to make changes without a full manual test pass is a genuinely different feeling.
Real-time sync has a timing problem nobody talks about. Getting live updates working is the easy part. The hard part is what happens when a Discord message creates a task while the web dashboard is open and the user is also creating something from the UI. Competing invalidations, race conditions in the cache, subtle flickers if query cancellation isn't handled correctly. Appwrite subscriptions are clean; the React Query coordination around them took several passes to get right.
Self-hosted infrastructure is a feature. Running OpenClaw locally adds a setup step and removes a whole category of problems: no third-party rate limits, no outage pages to monitor, no pricing surprises as the team grows. For a tool that every conversation about work flows through, ownership matters more than convenience.
Getting Started
git clone https://github.com/ARYPROGRAMMER/ManageMe.git
cd ManageMe
npm install
# Add your Appwrite credentials
cp .env.example .env.local
# Install OpenClaw
curl -fsSL https://openclaw.dev/install | sh
# Configure the skill
cat > ~/.openclaw/openclaw.json << 'EOF'
{
"skills": {
"entries": {
"manageme": {
"env": {
"MANAGEME_API_URL": "http://localhost:3000",
"MANAGEME_OPENCLAW_SECRET": "your-secret-here",
"MANAGEME_WORKSPACE_ID": "your-workspace-id"
},
"channels": {
"discord": { "enabled": true, "prefix": null },
"telegram": { "enabled": true, "prefix": null }
}
}
}
}
}
EOF
openclaw start
npm run dev
From clone to first natural language task: about ten minutes, most of which is setting up the Appwrite project.
What's Next
Better intent confidence. The current NLU layer handles clear task intent reliably, but gets uncertain in noisy channels. Adding a lightweight confirmation step — "did you mean to create a task for this?" — would extend it to messier environments without slowing down the clear-intent case.
Webhook triggers. Task events driving outbound webhooks — task completed posts to Slack, PR merged auto-closes the linked task. OpenClaw's skill chaining makes this a composition problem rather than a new integration.
AI-assisted extraction from threads. Summarize a long Discord discussion, extract the action items, surface them for quick review before creating. The LLM handles extraction; the human confirms. That handoff is the right place for AI in a workflow tool.
Bidirectional GitHub sync. Link tasks to pull requests, auto-close on merge, surface PR status in the task view. The interesting engineering problem is conflict resolution when both sides update simultaneously.
On the Problem Worth Solving
The reason context-switching between chat and project management feels so bad is that work doesn't happen in project management tools. It happens in conversations. The task board is a record of decisions already made. The conversation is where decisions happen.
ManageMe is a small attempt to close that gap — to make the place where decisions happen also the place where they get tracked. OpenClaw made it possible to build this without picking a platform and being stuck with it. The flexibility to meet teams where they already are, without committing to any one channel, is the whole point.
The project is open source. Contributions welcome at github.com/ARYPROGRAMMER/ManageMe. The live version is at manage-me-openclaw.vercel.app.
Reach out to me at arya.2023ug1104@iiitranchi.ac.in