DEV Community: Daniel Feldman

We built a Discord management team with AI agents

Daniel Feldman — Tue, 19 May 2026 14:44:53 +0000

Discord communities become operationally heavy surprisingly fast.

At first it's manageable.

Then suddenly:

support requests pile up
repeated questions flood channels
moderation becomes reactive
events get forgotten
analytics disappear
community management becomes full-time operational work

Most servers solve this by stacking more bots.

We wanted to experiment with something different.

A persistent multi-agent team.

At "OnBuzz Community" (https://github.com/Loxia-ai/onbuzz-community?utm_source=chatgpt.com) we've been building agent systems that can coordinate operational workflows more like real teams.

Instead of one bot, we split responsibilities

For example:

Support agent

Handles:

repeated questions
troubleshooting
onboarding
documentation retrieval
routing complex issues

Community manager agent

Tracks:

unanswered discussions
engagement drops
recurring friction
important conversations
moderation signals

Event/challenge agent

Manages:

events
reminders
contributor challenges
scheduling
participation tracking

Analyst agent

Monitors:

active users
retention
growth patterns
popular channels
community trends

Manager agent

Coordinates the others:

delegates tasks
validates outputs
follows up on unfinished work
schedules operational flows
creates specialized agents dynamically if needed

That last part became especially interesting.

The difference memory makes

Most bots are stateless.

The second the interaction ends, operational awareness disappears.

We wanted agents that could maintain continuity.

So we built:

short-term memory
long-term memory
event-based memory
recap systems to reduce drift during long operational loops

Agents can continuously reconnect to:

original objectives
server history
recurring issues
previous workflows
operational context

This changes the quality of autonomous execution dramatically.

Scheduling changed the workflow

One surprisingly useful capability:

Agents can schedule tasks for:

themselves
other agents
recurring operational workflows

Completely configurable.

This allows long-running operational loops without constant human supervision.

Full local history access

Another important thing for us:

Local-first interaction history.

Agents can retrieve historical context dynamically when needed instead of relying only on giant prompts.

Which makes long-term operational workflows far more stable.

What became interesting technically

The challenge stopped being:
"Can the model answer correctly?"

And became:

how agents coordinate
how context flows between them
how memory retrieval works
how long-running execution stays stable
how orchestration scales operationally

The system starts feeling much closer to infrastructure orchestration than chatbot workflows.

Why developers care

The interesting part isn't replacing community managers.

It's reducing operational drag.

Less:

repetitive coordination
constant follow-ups
context rebuilding
manually routing tasks

oversight
direction
execution leverage
parallel operational workflows

That's the area we're currently exploring.

Would genuinely love feedback from people building multi-agent systems in production.

Repo:
https://github.com/Loxia-ai/onbuzz-community

OnBuzz app:
https://onbuzz.loxia.ai

AI agents fail because they forget

Daniel Feldman — Mon, 18 May 2026 08:43:03 +0000

If you work with agents every day, you already know the pattern.

The first 20 minutes feel magical.

Then:

context starts drifting
requirements get forgotten
architecture decisions disappear
agents repeat mistakes
long runs slowly lose coherence

The problem is not model quality anymore.

The problem is memory architecture.

Most agent systems today are still built around temporary conversations instead of operational memory.

At OnBuzz we've been exploring what happens when you treat agents more like long-running workers inside a system instead of isolated chats.

Memory needs to behave more like humans do

One thing became obvious very quickly:

Not all memory should behave the same.

So we built layered memory systems:

short-term memory for active execution
long-term memory for persistent knowledge
event-based memory connected to actions, tasks, conversations, and decisions

That changes retrieval quality dramatically.

Instead of dumping giant context windows into prompts, agents can retrieve relevant operational context when needed.

Recap loops became critical

Long-running agents drift.

Even the best models do.

So we implemented internal recap mechanisms that continuously reconnect agents to:

the original objective
active constraints
completed work
unresolved blockers
execution history

This massively improves stability during long conversations and autonomous runs.

Full local interaction history

Another thing we wanted badly as developers:

Full access to interaction history locally.

Not just temporary chats.

Agents can retrieve context dynamically based on operational needs instead of relying purely on bloated prompts.

That changes debugging and long-running workflows completely.

Real multi-agent orchestration

Not "multiple tabs."

Actual orchestration:

teams
roles
task delegation
context sharing
work transfer between agents

Different agents handling:

architecture
implementation
validation
reviews
research
execution

In parallel.

Goal-driven autonomous execution

Agents can operate autonomously toward objectives with continuity between runs.

Not just one-shot prompts.

Combined with scheduling, agents can:

create recurring workflows
schedule tasks for themselves
schedule tasks for other agents
maintain operational continuity over time

(fully configurable, not enabled by default)

Manager agents and dynamic agent creation

One of the more interesting things we're exploring right now:

Manager agents that supervise other agents.

They can:

coordinate execution
monitor progress
delegate work
create specialized agents dynamically during runtime based on goals/tasks

We’re also experimenting with reusable skills that agents can generate and import into the system dynamically.

The workflow starts feeling much closer to coordinating engineering systems than manually operating chats.

CLI-first + local-first

We wanted the system to feel native to developers.

CLI-first.
Local-first.
Full control.

Your data stays with you.

Why this matters

The biggest productivity gain is not:
"AI writes code faster."

It's reducing operational overhead.

Less:

rebuilding context
repeating instructions
manually coordinating workflows
re-checking obvious things
fighting context collapse

architectural thinking
execution leverage
parallel workflows
shipping systems faster

The highest leverage developers are usually not the fastest typers.

They're the ones who can coordinate complexity efficiently.

That's the workflow shift we're interested in exploring.

If this space interests you, we'd genuinely love feedback from people building with agents daily.

⭐ on the repo helps a lot:
https://github.com/Loxia-ai/onbuzz-community

We're also opening a contributor core with bounties and cloud credits for the full platform.