Hi everyone,

I’ve been building NexAgent, an AI agent system designed for long-running, real-world use, and I thought it might be interesting to share here because the project is deeply shaped by Elixir/OTP.

Most agent projects I see are optimized for one-shot tasks: run a prompt, call a few tools, return a result, exit.

NexAgent is aimed at a different problem:

• keep an agent online
• put it inside chat apps people already use
• give it persistent sessions and memory
• let it run background jobs
• make it capable of improving over time

In practice, the project currently focuses on two core ideas:

• Self-evolution
• Elixir/OTP as the runtime foundation

Why Elixir/OTP

For a short-lived agent script, the runtime is often secondary.

For an agent that is supposed to stay online, manage multiple chat surfaces, isolate failures, run scheduled tasks, and eventually support hot updates, OTP starts to matter a lot more.

That’s the main reason I chose Elixir.

NexAgent uses OTP concepts as product-level building blocks rather than just implementation details:

• supervision trees for long-lived services
• process isolation between components
• GenServer-based managers for sessions, tools, cron, and channel connections
• fault recovery for message handling and background work
• a path toward hot code evolution and rollback

What NexAgent does today

Right now, the project includes:

• chat app integration via a gateway layer
• long-running sessions scoped by channel:chat_id
• persistent memory and history
• built-in tools for file access, shell, web, messaging, memory search, scheduling, and more
• a skill system for reusable capabilities
• cron jobs and subagents for background work
• reflective/evolutionary tooling for source-level self-improvement

Supported chat channels in code today include:

• Telegram
• Feishu

The part I find most interesting

The project’s real goal is not “wrap one more model API”.

It is to explore what an agent system looks like when you take these questions seriously:

• How should memory work beyond a single context window?
• How should sessions be isolated across chat channels?
• How should background work be scheduled and supervised?
• How should an agent evolve beyond prompt edits?
• What does source-level self-modification look like in a runtime that already supports hot code loading and supervision?

That combination is what made Elixir feel unusually well-suited for this kind of system.

Current status

This is still an early-stage project, but the architecture is already oriented around:

• Gateway
• InboundWorker
• Runner
• SessionManager
• Memory / Memory.Index
• Tool.Registry
• Cron
• Subagent
• Evolution
• Surgeon

The broader direction is to build an agent that is not just configurable, but persistent, operational, and evolvable.

If this overlaps with your interests in OTP systems, long-running AI services, or agent architecture, I’d be very interested in feedback.

Especially on questions like:

• whether Elixir feels like the right long-term runtime for this category
• how far hot upgrades should be pushed in an agent system
• where OTP gives the biggest advantage over more conventional agent stacks

Thanks for reading.

Repository:

https://github.com/gofenix/nex-agent