← Back to Blog

June 8, 2026

From Telegram to Published Post: My Obsidian + Hermes Writing Pipeline

My website is an Obsidian vault. Here's how Hermes, obsidian-git, and Astro turn a voice memo into a published blog post with almost no friction.

obsidianaiproductivityhermestools

This is part three of my Hermes series. Part one introduced the agent on my desktop, part two covered reaching it from Telegram. This post is about the final piece: where everything lands. Because the secret of this website is that it isn’t just built from my notes — it is my notes.

The vault is the website

I’ve written about why I love Obsidian: plain Markdown files, local-first, no proprietary format. That post buried the lede on the best consequence of plain files — anything that speaks Markdown can be an Obsidian vault. Including a website repository.

My site is built with Astro, which renders blog posts from Markdown files in a content folder. So I opened the repo itself as an Obsidian vault. The blog directory in Obsidian’s sidebar is the production content directory. There is no export step, no copy-paste, no CMS. A note in that folder with valid frontmatter is a blog post.

Publishing a post means a Markdown file appears with a few frontmatter fields:

---
title: "Your Post Title"
description: "A brief summary of the post"
date: "2026-06-08"
tags: ["cybersecurity", "tools"]
draft: false
---

Astro’s content collections validate that frontmatter against a schema at build time, so a typo’d date fails the build instead of silently breaking the page. Type checking for blog posts. As someone who believes in validating inputs, I love this.

obsidian-git closes the loop

The vault runs one community plugin: obsidian-git. On a schedule, it commits everything and pushes to GitHub. My commit history is full of timestamped vault backup commits — that’s the plugin doing its job. The push triggers the site build, and the post is live.

So the full publishing stack is: Obsidian for writing, git for sync and history, Astro for rendering. Every layer is plain text, every layer is auditable, and no layer is a subscription service that can disappear with my content.

Where Hermes fits

Here’s where the series comes together. Hermes runs on the same machine the vault lives on, with file access to it. Combined with the Telegram bridge from part two, the pipeline looks like this:

  1. Capture, anywhere. A voice memo or message to Telegram: “draft a post about X, here are my main points.” Hermes transcribes it and writes a draft into the vault using my blog post template, frontmatter included, draft: true.
  2. Edit, at the desk. The draft is sitting in Obsidian when I open it. I rewrite in my own voice — the agent drafts, but the words that ship are mine. This step is not optional and never will be.
  3. Publish, by flipping a flag. Set draft: false, and obsidian-git’s next scheduled push takes it live.

The agent also handles the housekeeping I used to skip: checking frontmatter against the schema, suggesting tags consistent with my existing taxonomy, and confirming via Telegram that the nightly vault backup pushed cleanly. Small things, but small frictions are what kill publishing habits.

Why this beats a CMS

I went down the usual roads first: hosted CMS platforms, static site generators with admin panels, even a brief Notion-as-CMS experiment. They all failed the same test — the writing tool and the publishing tool were different places, and every transition between them lost momentum or formatting.

This pipeline has properties I’d defend in any architecture review:

One source of truth. The vault is the site. No sync drift, no “which version is current.”

Everything is recoverable. Plain Markdown in git. Full history of every edit. If Obsidian, Hermes, and Astro all vanished tomorrow, my content is still readable text in a repo.

Each component is replaceable. Obsidian is just an editor pointed at files. Astro is just a renderer. Hermes is just a contributor with commit access. Swap any one without touching the others.

The trust boundary is explicit. The agent writes drafts; only I flip draft: false. An AI with a path to my public website is exactly the kind of thing that needs a human approval gate, and the frontmatter flag is precisely that — simple, visible, and in the diff.

The numbers

Before this pipeline, a post took me a full evening, and the gap between idea and draft was where most posts died. Now capture is instant, drafting is delegated, and my time goes into the part that actually needs me: the thinking and the editing. I’m publishing weekly and it doesn’t feel like a grind.

Key Takeaways

  • Because Obsidian vaults are just folders of Markdown, your website repo can be your vault — no export step, no CMS.
  • Astro content collections give you schema validation on frontmatter, catching broken posts at build time.
  • obsidian-git turns scheduled vault backups into automated publishing.
  • Hermes plus Telegram makes capture instant: a voice memo becomes a properly formatted draft sitting in the vault before I’m home.
  • Keep the human in the loop with an explicit gate. The agent drafts; only I publish. The draft flag is the trust boundary.