DEV Community: Alessio Leodori

Your shell history is missing the most important part of AI terminal sessions

Alessio Leodori — Tue, 31 Mar 2026 15:27:18 +0000

Shell history breaks the moment you start working with AI agents in the terminal.

Not because it is slow.

Not because it is ugly.

Because the most important data is simply missing.

The problem with shell history

Your shell history only shows the commands you typed yourself.

That means you see:

your manual commands
your own navigation
your own retries

But you do not see:

the commands the agent ran
the subprocesses it spawned
the sequence of actions it took inside the session
the terminal output it saw while making decisions

So after an AI-assisted session, your history gives you a partial story.

And partial stories are terrible for debugging.

A concrete example

Imagine you used Codex CLI, Claude Code, or another agent in your repo.

Later, something is wrong:

a branch changed
a file was rewritten
a test was run
a commit appeared

You open shell history to understand what happened.

And what do you get?

Only the commands you typed manually.

The agent activity that actually shaped the session is missing.

So you end up in a bad spot:

you know something happened
you know the agent did work
but the default terminal tools do not show you the data you need

That is the real gap.

The issue is visibility into agent-produced session data

Traditional shell history was never designed to answer questions like:

What exactly did the agent run?
What output did it see before taking the next step?
What happened between the two manual commands I remember typing?
What state was the repo in at that exact moment?

If the data is not recorded, you cannot inspect it later.

And that is exactly what happens with most terminal setups today.

What I built instead: Agensic Replay

Agensic Replay is built around a different assumption:

👉 if an agent can act in your terminal, the session itself needs to be recorded and replayable

Instead of relying on shell history, Agensic tracks the session as a real timeline.

That lets you:

replay terminal sessions
browse event timelines
inspect what happened step by step
export the session dataset to JSON or CSV

So instead of asking shell history for information it never captured:

👉 you can inspect the actual session

Why replay matters

This changes the debugging workflow completely.

Without replay, investigating an agent session usually turns into:

scrolling history
guessing what the agent probably ran
checking git status
digging through reflog
trying to reconstruct events from incomplete evidence

With replay, you do not need to guess.

You can open the session and see how it unfolded.. The actual tracked session.

Replay is useful because the missing data is now present

That is the key point.

Agensic Replay exists because shell history is missing the crucial data in the first place.

Replay works because Agensic records:

the terminal session
the event timeline
the agent-driven activity
the repo checkpoints tied to the session

Once that data exists, you can finally answer the questions that normal shell tooling cannot answer.

Then came the most useful part: Git Time Travel

Once sessions were replayable, the next obvious problem was recovery.

Because understanding what happened is great.

But often you also want to go back to a precise moment and inspect safely.

So Agensic adds Time Travel on top of Replay.

That means you can jump back to the exact Git state captured at a specific session checkpoint.

Not roughly the right point.

Not “somewhere before the bad commit.”

👉 the exact repo state tied to that session moment

And it restores that state into a new branch, so you can investigate without destroying your current working tree.

What started as a session visibility problem became a more complete workflow:

replay → see the session data shell history never captured

timeline → inspect the sequence of events

time travel → restore the exact repo state from a checkpoint

export → keep evidence for incident review or debugging

Because with AI agents, the bottleneck is no longer just execution.

It is whether the session remains inspectable after the fact.

Final thoughts

If you use AI agents in the terminal, shell history is no longer enough.

Not because history is old.

Because it only records the human-visible slice of the session.

The agent can generate a lot of important activity, and by default that data just disappears from view.

That is the problem Agensic is trying to solve.

If you’re curious

Agensic is open source here:

👉 https://github.com/Alex188dot/agensic

If you are using AI agents in the terminal, I would especially love feedback on the replay and time-travel workflow!

Why terminal autocomplete is still terrible (and what I built instead)

Alessio Leodori — Thu, 26 Mar 2026 19:41:59 +0000

Terminal autocomplete hasn’t really evolved.

It’s still:

prefix-based
fragile to typos
unaware of how you actually work

It’s fast, sure. But it’s not helpful.

The problem with terminal autocomplete

Most shells do one thing well:

👉 complete what you already started typing

That’s it.

If you type:

dokcer logs

You get nothing.

If you type:

docker rec

You also get nothing.

Even though:

you meant docker
you probably ran docker logs 100 times before

The shell doesn’t care.

It doesn’t learn.
It doesn’t adapt.
It just matches prefixes.

What I wanted instead

I wanted something that:

learns from my actual command history
fixes typos automatically
understands intent, not just prefixes
stays instant (no lag while typing)

So I built a different kind of autocomplete.

A better autocomplete (Agensic Autocomplete)

Instead of treating commands as static strings, I treat them as patterns.

That enables things like:

dokcer → docker
docker records → docker logs

And importantly:

👉 it stays local-first and fast

AI is only used as a fallback when your history isn’t enough.

Most of the time, suggestions come from:

your own repo-aware past commands, ranked on usage
semantic matching
typo correction

It feels closer to an IDE than a shell.

But autocomplete wasn’t the real problem

Once I started using AI agents in the terminal (Codex CLI, Claude Code, etc...), I realized something else:

Autocomplete helps you write commands.

But it doesn’t help you understand what actually happened.

The missing layer: command provenance (Agensic Provenance)

When an agent runs commands for you, things get blurry fast.

Shell history doesn’t track commands ran by agents, it's as if they are acting in a black box.

So I added a provenance layer.

Every command gets classified and tracked:

HUMAN_TYPED
AI_SUGGESTED_HUMAN_RAN
AI_EXECUTED
etc.

And for agent-executed commands, there’s cryptographic proof.

So instead of guessing:

👉 you get a clear, auditable timeline of what actually ran and why

Then came sessions (Agensic Sessions)

The next problem showed up quickly:

Even if you know what ran…

👉 you still can’t easily reconstruct the full session

So I added session tracking.

Now you can:

replay entire terminal sessions
inspect command timelines
export runs for debugging or incident review

And the most useful feature:

Time travel for your repo

You can jump back to the exact state your repository was in at a specific moment.

Not “roughly what I remember”
Not “git reflog archaeology”

👉 the exact state tied to a session checkpoint

Putting it together

What started as “better autocomplete” turned into something else:

autocomplete → helps you write faster
provenance → helps you understand what happened
sessions → help you reconstruct and debug

Because once AI agents enter the terminal:

👉 speed is no longer the bottleneck
👉 understanding is

Final thoughts

Terminal tooling hasn’t really caught up with how we work today.

We’re no longer:

just typing commands
just running scripts

We’re:

collaborating with agents
delegating execution
moving faster than we can track

And without visibility, that breaks down quickly.

If you’re curious

I open sourced the project here:
👉 https://github.com/Alex188dot/agensic

Would love feedback, especially from people using AI agents in the terminal.