If you work with AI coding agents long enough, you run into the same problem:

the agents are productive, but the workflow around them gets chaotic.

One Claude Code session is writing tests. Another is refactoring something risky. A Codex session is halfway through a change you barely remember prompting. One tab is busy, one is idle, one is blocked, and none of
them make it especially easy to understand the full picture at a glance.

That problem is what led me to build AgentPulse.

AgentPulse is an open source, real-time dashboard for monitoring Claude Code and Codex CLI sessions. Its job is simple: make multi-agent workflows observable.

The problem

Running one agent session is easy.

Running several at once is where things start to break down.

You end up asking questions like:

• Which tab is working on what?
• Which session is actually doing useful work?
• Which one is stuck?
• What did I ask this session 20 minutes ago?
• Which project is this agent operating in?
• Why do I have four terminals open and no clear mental model of what is happening?

The tooling around AI agents is getting better quickly, but visibility across sessions still feels primitive. Each session often lives in its own terminal world. That works until you start using agents the way many
of us actually want to use them: in parallel.

I wanted something that gave me a live operational view of my agents, the same way dashboards help with infrastructure, deployments, and services.

What AgentPulse does

AgentPulse gives you a single place to see what your active agent sessions are doing.

It currently supports:

• live session monitoring for Claude Code and Codex CLI
• real-time updates through a web dashboard
• human-friendly session names so it is easier to match sessions to terminal tabs
• session detail views with prompt history and timeline context
• tool usage visibility
• notes per session
• CLAUDE.md / AGENTS.md viewing and editing
• local-first setup through hooks
• relay support for remote dashboard access

The core idea is not complicated. Agent sessions already emit useful signals. AgentPulse collects those signals, stores them, and turns them into something you can actually reason about while work is happening.

Why I built it

I did not build AgentPulse because I wanted another dashboard for the sake of having a dashboard.

I built it because once AI agents became part of my normal workflow, I felt a gap between “the agent can do work” and “I can confidently manage several agents at once.”

That gap matters.

A lot of the conversation around coding agents focuses on capability: can they code, debug, refactor, search, plan, and execute?

That matters, but once you start using these tools daily, the next problem is coordination.

You need visibility.
You need context.
You need a way to check in on active work without re-entering every terminal and reconstructing what is going on.

AgentPulse is my answer to that.

Local-first by design

One thing I cared about from the start was keeping the setup practical.

A lot of developer tools become less appealing the second they require a big hosted control plane, heavy configuration, or a bunch of infrastructure just to be useful.

AgentPulse is intentionally local-first.

You can run it locally, point your agent hooks at it, and immediately get value. If you want remote access later, there is a relay model for that. If you want more elaborate deployment setups, those can come later.

But the baseline experience should be simple: run it, connect your agents, open the dashboard, and understand what is happening.

That principle continues to shape the project.

Where it is going

There are a few areas I am actively interested in improving.

One is better Codex session naming and status visibility. Claude Code and Codex have different surfaces and different limitations, so making the experience clean across both takes some work.

Another is non-Docker local deployment. I want local Bun + SQLite installs to be a first-class path, not just an alternative for people who do not want containers.

I am also exploring a more advanced managed Codex mode, where AgentPulse could integrate more directly with Codex’s supported control surfaces instead of relying only on hooks and passive observation.

The main rule for future work is straightforward: any new capability should make parallel agent workflows easier to manage in the real world.

Open source and feedback

AgentPulse is open source because I think this problem is bigger than my own workflow.

A lot of people are converging on similar patterns:
multiple agents, multiple terminals, multiple tasks, and not enough visibility across them.

If that sounds familiar, I would be interested in your feedback.

Questions I care about:

• What do you most want to see from active agent sessions?
• What information is still missing from the dashboard?
• What would make a tool like this indispensable instead of merely useful?

You can check out the project here:

https://github.com/jaystuart/agentpulse

If you take a look and think it is useful, dropping a star helps with visibility and makes it easier for other people to find it.

Closing thought

I think AI coding tools are moving from “interesting assistants” toward “parallel working systems.” Once that happens, observability stops being optional.

If you are going to run multiple agents seriously, you need a way to see the work as it is happening.

That is the reason AgentPulse exists.