The Source Cabinet

I have this habit now where I send a link to Hermes and say something like:

read and analyze and critique this

Sometimes I add the project:

this is for ilteris-daily

That part works surprisingly well. Hermes reads the thing, pulls in project context, argues with me a little, and we go back and forth. It feels natural. It is basically the relationship surface I want.

The sloppy part is what happens after.

Sometimes I remember to finalize the conversation. Sometimes I do not. Sometimes I ask Hermes to create a Markdown note in Obsidian. Sometimes the note is useful. Sometimes it is technically correct but loses the part of the conversation that actually mattered. And sometimes the whole thing is just trapped in a linear chat history where retrieval is possible in theory and annoying in practice.

So when I started looking at wallabag, the first question was not “can this replace Readwise?” It was more like:

Am I accidentally rebuilding my Obsidian vault again?

And then a second question:

Am I actually trying to rebuild Hermes because Hermes is the sloppy part?

I think the answer is no to both, but only if the boundaries stay sharp.

The Boundary

The shape that feels right is:

Hermes   = conversation
wallabag = source cabinet
Soul     = durable ledger
Obsidian = authored synthesis

That is the whole design.

Hermes should remain where I talk. I do not want to open a different UI just to get an insight about a link. If I am on my phone, the flow should still be: paste the link into Hermes, say what I want, get the analysis.

wallabag should be boring. It should save the source, clean it up, keep the readable version, and expose it through an API. I like wallabag because the UI is clean and narrow. That is the point. It should not become my new thinking environment.

Soul should remember what happened. Not in a vague “the chat exists somewhere” way, but as durable events: source saved, annotation added, session finalized, project context attached.

Obsidian should stay where promoted ideas go. If something becomes an essay, a plan, a project note, or long-term synthesis, then yes, move it to the vault. But not every article I read needs to begin its life as an Obsidian note.

This is the part I kept almost missing. The systems should touch, but they should not collapse into one another.

The Old Flow

Before this, the flow was basically:

copy link
paste into Hermes
ask for analysis
talk
maybe finalize
maybe create an Obsidian note
maybe forget

The nice thing about this is that there is almost no friction. I am already in Telegram. I am already talking to Hermes. I do not need to classify the link before I know whether it is worth caring about.

The bad thing is that the source is not a first-class object.

Hermes may read it. The conversation may mention it. The final note may summarize it. But the article itself, the analysis, and the eventual durable memory are not cleanly tied together.

That is exactly the kind of thing that becomes fine for one article and messy after fifty.

The Friction Trap

The obvious wallabag-first flow would be:

share link to wallabag
tag it
maybe add intent
wait for capture
then ask Hermes to analyze it
then maybe save the conversation

I do not like that.

It asks me to do filing work before I have gotten value. It makes wallabag the front door, even though Hermes is the place where I actually start thinking. It also creates a weird interruption problem: if I am already talking to Hermes about something else, I now have this parallel capture workflow that has to rejoin the conversation later.

That is backwards for how I use this.

I do not want “share to wallabag” to be the primary ritual. I want “tell Hermes what I want” to stay the ritual.

So the rule became:

Hermes should save the source to wallabag automatically when a link appears in a project-bound conversation.

That sounds small, but it changes the workflow. I still get the low-friction Hermes behavior, but the source becomes durable without me doing separate librarian work.

The New Flow

The flow now looks like this:

1. I paste a link into Hermes.
2. Hermes sees the URL and knows the active project.
3. Hermes saves the source to wallabag with project tags.
4. Hermes reads the cleaned wallabag text when it needs source context.
5. Hermes and I talk normally.
6. Hermes gives me a Source Reader URL.
7. If I say "save this as annotation", Hermes writes a source note.
8. If I run /finalize, Soul writes the session summary back against that source.
9. The Source Reader shows the article with the Hermes/Soul notes next to it.

The important thing is step one. It did not change.

I still just throw the link at Hermes.

The rest is infrastructure.

Why There Is a Source Reader

At first I was unsure where the overlay should live.

Should wallabag display the summary? Should we customize the wallabag UI? Should there be a conversation layer inside wallabag? Should this become some kind of mini research workspace?

I think no, at least for now.

The cleaner shape is a Hermes-generated Source Reader page.

It is not wallabag. It is a view over wallabag.

It is not Obsidian. It is not creating a new Markdown note.

It is not the Hermes chat. It is not trying to be conversational.

It is just a generated page that says:

show me this saved source
and show me what Hermes/Soul knows about it
for this project

That page can fetch the cleaned article from wallabag and fetch the source-linked notes from Soul. It can render them together without making either system pretend to own the other.

That is why I like it. It is a read model, not a new source of truth.

What Finalize Means Here

This made /finalize feel more concrete.

Before, finalization meant “make this session durable.” That is still useful, but it can be a little abstract. The session is durable somewhere in Soul, but when I come back to the article, I may not see the thinking that happened around it.

Now finalization can attach a SourceNote to the wallabag entry.

Something like:

source: wallabag entry 8
project: ilteris-daily
kind: finalize summary
content: the useful residue of the Hermes conversation

Then when I open:

http://<mac-mini-tailnet>:9119/source-reader?entry=8&project=ilteris-daily

I see the clean article and the note together.

That is the part that feels right. The thought is attached to the thing I was reading when the thought happened.

Not buried in chat. Not prematurely promoted to Obsidian. Not mixed into wallabag’s own article text. Attached as a separate layer.

The Bug That Made the Design Clearer

There was a funny implementation bug that clarified the architecture.

Hermes was saving the URL to wallabag correctly. Soul had the wallabag references. The source existed. But the Telegram reply did not always include the Source Reader URL.

Why?

Because the response had already streamed. The post-processing code tried to append the URL after the visible reply was already sent.

So the actual failure was not:

wallabag capture failed

It was:

visible affordance failed

That distinction matters.

The fix was simple: if Hermes can append the Source Reader link before sending, append it. If the main response already streamed, send a small trailing message with the link.

This is also why the ledger is useful. Without Soul, I would have been guessing where the failure was. With the ledger, I could see that capture worked and delivery was the missing piece.

What This Is Not

This is not Readwise.

This is not Obsidian.

This is not a universal annotation product.

This is not “every article gets AI notes now.”

It is narrower than that:

I want to read something in the context of a live project, talk through it with Hermes, and keep the useful residue next to the source so I can return to it later.

That is it.

The more I build this stuff, the more I think the trick is not to make one perfect app. It is to give each surface one honest job.

Hermes should feel like Hermes.

wallabag should stay clean.

Soul should be strict about memory.

Obsidian should be for the things I actually promote.

And the Source Reader should be the little bridge that lets me revisit the article and the thinking around it without reopening the whole conversation.

That feels like the right shape.