Build Your Personal AI Command Center

Give your AI agent persistent memory and Telegram reminders.

Introduction

30 Second Summary

Think about how many times you've re-explained yourself to an AI. Every new conversation starts from scratch with no memory of your name, your projects, or your preferences.

In this project, you will turn Hermes Agent into your personal AI command center. You'll teach it who you are, schedule automated reminders, connect Telegram for push delivery, and explore a visual timeline of everything your agent has learned about you.

What You'll Build

Your AI agent greets you by name, remembers your projects and preferences from last time, and while you step away it runs scheduled tasks on autopilot and pings you on Telegram with the results.

By the end of this project, you'll have:

An agent with persistent memory that carries your name, projects, tools, and preferences across every conversation.
Automated cron reminders that run on a schedule and deliver output straight to your phone via Telegram.
A Journey graph that visualizes everything your agent has learned as a playable constellation timeline, plotted from oldest to newest.
Secret Mission: Chain two cron jobs so one's output feeds the next, building a multi-stage automation pipeline.

Are there any prerequisites?

This project builds on Set Up Hermes Agent for Free. You need Hermes Agent installed and configured with an LLM provider (OpenRouter or Anthropic) before starting.

You also need a Telegram account. If you don't have one yet, Step 4 includes setup instructions.

Before We Start

Before we dive in, let's lock in what you're about to build and why it matters.

Open Your Command Center

Your Hermes Agent is installed, but right now the only way to interact with it is through the terminal. To track the memory entries, sessions, and cron jobs you'll build throughout this project, you need a visual hub that puts everything in one place.

In this step, you'll launch the Hermes web dashboard and confirm your LLM provider is responding. This dashboard is where you'll monitor everything your agent learns and does.

In this step, get ready to:

Confirm Hermes is installed and launch the web dashboard.
Verify your LLM provider responds through the dashboard Chat tab.

Verify Hermes and launch the dashboard

Before building anything, confirm that Hermes is reachable from your terminal and that the dashboard dependencies are in place.

Open your terminal by pressing Ctrl+Alt+T.
Confirm Hermes is installed by running this command:

hermes --version

You should see a version number printed in your terminal.

✔️ I see a version number

Hermes is ready. Move on to launching the dashboard below.

ⓧ Command not found

Hermes is not installed on this machine. Complete the prerequisite project first:

Set Up Hermes Agent for Free.

Once that project is complete, return here and re-run the version check.

Launch the web dashboard by running this command:

hermes dashboard

What does this command do?

This starts a local web server on port 9119 and automatically opens http://127.0.0.1:9119 in your browser. The dashboard runs entirely on your machine. No data leaves localhost.

This command takes over your terminal while the server is running. You'll need to open a new terminal tab or window for any future terminal commands. Press Ctrl+C when you want to stop the dashboard.

✔️ The dashboard opened in my browser

The dashboard is running. Move on to confirming your tabs below.

ⓧ I see a message about missing dependencies

The default Hermes install does not include the dashboard's HTTP stack. Hermes tells you what to install when you run the command without them.

Install the dashboard dependencies by running this command:

pip install 'hermes-agent[web,pty]'

What are these extras?

The web extra installs FastAPI and Uvicorn, which power the dashboard's web server. The pty extra installs ptyprocess, which lets the Chat tab run the full Hermes TUI inside your browser.

Launch the dashboard again by running:

hermes dashboard

Your browser should now open to the dashboard.

Dashboard still not opening?

Make sure pip installed the extras without errors. Look for a success message at the end of the install output. If the install failed, check that your Python environment matches the one Hermes was installed into.

help me troubleshoot the Hermes dashboard not launching after installing dependencies

Confirm your dashboard tabs

Your dashboard should now be open at http://127.0.0.1:9119 in your browser.

Confirm you see five tabs across the top of the page: Status, Sessions, Memory, Config, and Chat.

What do these tabs do?

Status shows your system health and model configuration.
Sessions lists your past conversations with Hermes.
Memory shows what Hermes remembers about you. This will be empty for now.
Config lets you manage settings and API keys from the browser instead of editing YAML files.
Chat is a browser-embedded terminal for talking to your agent. Everything you can do in the terminal TUI works identically here.

Keep this terminal running

The dashboard process is running in your original terminal. Open a new terminal tab or window (Ctrl+Shift+T for a new tab in most Linux terminals) for any future commands. You'll need this in the next step.

Send a test message

The dashboard is up, but you need to confirm the LLM provider you configured in the prerequisite project is still responding. The Chat tab lets you test this directly from the browser.

Click the Chat tab in your dashboard.

Before you type anything, what do you expect to happen if your LLM provider is configured correctly?

Type a test message and press Enter:

What model are you running on?

Hermes should respond with the name of the model it's currently using. This confirms your LLM provider is working and connected.

Not getting a response?

Check the Status tab. It shows which model and provider are configured. If the provider field is empty or shows an error, your API key may have expired since the prerequisite project.

Open the Config tab and verify your API key is still set. You can update it directly from the browser.

help me debug why Hermes isn't responding to chat messages in the dashboard

Your command center is live and your agent is responding. Next up, you'll teach Hermes who you are so it can remember you across every session.

Teach Hermes Who You Are

Your dashboard is live and your LLM provider is confirmed working. Now it's time to give Hermes Agent something no generic chatbot has: memory of who you are and what you care about.

Hermes has a persistent memory system that carries facts across every conversation. Right now that memory is completely empty. Without it, every session starts from scratch and your agent can't act as a true personal assistant.

In this step, get ready to:

Seed Hermes' persistent memory with your name, role, projects, and preferences.
Verify what Hermes stored in the dashboard Memory tab and on disk.
Correct any inaccurate entries through follow-up conversation.

Have a conversation that seeds memory

Hermes automatically saves relevant facts from your conversations into persistent files. These files are loaded into every future session, so your agent always knows who it's talking to.

Switch to the Chat tab in the dashboard. You can also open a new terminal and run hermes to use the TUI instead.
Tell Hermes about yourself. Be specific and personal. Share the following details:

Your name and current role.
A project you're currently working on.
The tools and programming languages you use.
Whether you prefer concise or detailed responses.
Your timezone.

For example, you might type: "My name is Alex. I'm a junior developer working on a portfolio site with React. I use VS Code and prefer concise responses. My timezone is US Eastern."

Where does Hermes store your memory?

Hermes saves facts to two files inside ~/.hermes/memories/.

MEMORY.md holds environment and project facts (your name, role, projects, tools, timezone) with a 2,200 character limit.
USER.md holds your preferences and profile (response style, personal preferences) with a 1,375 character limit.

The agent manages these files automatically using its built-in memory tool. You never need to edit them by hand.

Check what Hermes remembered

Switch to the Memory tab in the dashboard.

You should see the entries Hermes saved from your conversation. Your name, projects, tools, and preferences should all appear as stored facts.

Verify the same data from your terminal by running these commands:

cat ~/.hermes/memories/MEMORY.md

Check your user profile by running:

cat ~/.hermes/memories/USER.md

MEMORY.md should show your environment facts like your name, role, current projects, tools, and timezone. USER.md should show your personal preferences like your response style.

Memory tab is empty?

Make sure you shared enough detail in your conversation. Try telling Hermes at least three specific facts about yourself in one message.
Hermes decides what's worth remembering. If you gave very short answers, try a longer, more detailed message like "I'm working on a React portfolio site using VS Code and TypeScript."
Check that your LLM provider is still responding. Switch to the Chat tab and confirm Hermes replies to a basic question.
Why isn't Hermes saving anything to memory?

Correct any inaccurate entries

Hermes may have summarized or misinterpreted something you said. You can correct it directly in conversation without editing any files.

Return to the Chat tab.
If any entry is wrong, tell Hermes directly. For example: "Actually, I use VS Code, not Vim."
If everything looks accurate, tell Hermes one more fact it hasn't saved yet to build out your profile further.

How does Hermes correct memory?

Hermes uses its memory tool's replace action to find the incorrect text and swap it with the corrected version. It can also remove entries entirely if something is no longer relevant.

Before you check, take a moment to predict: what entries do you expect to see in the Memory tab now? Do you think your correction (or new fact) is already saved?

Switch to the Memory tab in the dashboard.

You should see entries about your name, projects, and preferences. Any corrections you made should be reflected, and any new facts should appear alongside the originals.

Still seeing old information?

Memory updates happen when Hermes processes your correction message. Send a clear, direct correction and wait for Hermes to confirm the change before rechecking the Memory tab.
Try refreshing the dashboard page in your browser to pick up the latest state.
Why didn't Hermes update my memory after I corrected it?

Your agent now knows who you are, what you're working on, and how you like your answers. Next up, you'll put Hermes to work on a schedule by creating your first automated cron reminder.

Schedule Your First Reminder

Hermes knows your name, your projects, and your tools. But right now it only does anything when you open a chat and ask.

A personal assistant that waits for you to remember to ask is barely an assistant. In this step, you'll give Hermes Agent a scheduled task that runs on autopilot, whether you're paying attention or not.

In this step, get ready to:

Create a recurring cron job that fires every 30 minutes.
Verify the job exists and manually trigger it.
Find the output and discover the delivery gap that the next step fixes.

Create a recurring cron job

Hermes has a built-in cron scheduler that runs tasks on a timer. Each job gets a prompt, a schedule, and a name you choose.

Create a stretch-reminder cron job by running this command in your terminal:

hermes cron create "every 30m" "Remind the user to take a break and stretch. Include the current time and a motivational quote." --name "stretch-reminder"

What does this command do?

This tells Hermes to create a recurring job with three pieces of information.

"every 30m" is the schedule. Hermes understands natural time expressions like every 30m or daily at 9am.
The second quoted string is the prompt. Each cron job runs in a completely fresh session with no memory of previous runs, so the prompt must be self-contained.
--name "stretch-reminder" gives the job a human-readable name you can use instead of the hex ID.

You should see a confirmation that the job was created.

Natural language works too

You can also create cron jobs by talking to Hermes naturally in the Chat tab or terminal. Try something like: "Every 30 minutes, remind me to take a break and stretch. Include the current time and a motivational quote."

Hermes uses its built-in cronjob tool internally to schedule the job for you. The CLI command gives you more control over the exact name and schedule.

Seeing a command error?

Make sure you have matching double quotes around both the schedule and the prompt. A missing or mismatched quote will break the command.
If you see command not found, confirm Hermes is installed by running hermes --version.

Help me debug a hermes cron create command that isn't working.

Verify the job and trigger it

List your cron jobs by running:

hermes cron list

Your stretch-reminder job should appear with its schedule and next run time.

Job not showing up?

If the list is empty, the hermes cron create command may have failed silently. Scroll up in your terminal to check for any error messages from the create step.
Re-run the hermes cron create command from the previous substep. Make sure all quotes are balanced.

Help me figure out why my cron job isn't appearing.

You don't have to wait 30 minutes to see if it works. Before you trigger it manually, what do you think will happen? Will you see the output in the terminal, or somewhere else?

Trigger the job immediately by running:

hermes cron run stretch-reminder

Why use the name instead of an ID?

Hermes cron commands accept a job name (case-insensitive) in place of the hex ID. Since you named the job stretch-reminder, you can use that name for run, edit, pause, and remove without copying hex strings.

Find the output (and the problem)

The job ran. Now the question is: where did the output go?

Check for output files by running:

ls ~/.hermes/cron/output/

You should see a folder named with your job's hex ID. This is where Hermes saves cron output.

Read the reminder content by running this command, replacing the folder name with the one shown by ls:

cat ~/.hermes/cron/output/[[CRON_JOB_ID="the folder name from the ls output above"]]/*.md

The reminder looks great. You should see a motivational message with the current time, exactly as you prompted.

Where does cron output live?

Each job's output is saved to ~/.hermes/cron/output/{job_id}/{timestamp}.md. The job definitions themselves are stored in ~/.hermes/cron/jobs.json.

Now look at what just happened. The reminder ran and the content is solid. But it's sitting in a Markdown file buried inside ~/.hermes/cron/output/ on your machine.

You'd never actually see this unless you remembered to SSH in and check. That's not a personal assistant. That's a diary nobody reads.

No output folder showing up?

Make sure you ran hermes cron run stretch-reminder in the previous substep and waited a moment for it to finish.
Check the exact path: the output folder is inside ~/.hermes/cron/output/, not ~/.hermes/cron/ directly.

Help me find my cron output.

Your cron job works perfectly. The only thing missing is a way to reach you where you are. In the next step, you'll connect Telegram so reminders arrive on your phone instead of hiding in a local file.

Deliver Reminders to Telegram

In Step 3, you created a cron job that generates stretch reminders on a schedule. The output looked great, but it was sitting in a file on your machine that you'd never actually check.

A real personal assistant needs to reach you where you are. Hermes has a built-in messaging gateway that delivers cron output straight to Telegram. In this step, you'll create a Telegram bot, connect it to Hermes, and watch your reminder arrive as a message on your phone.

In this step, get ready to:

Create a Telegram bot via @BotFather.
Configure the Hermes messaging gateway to connect to Telegram.
Deliver your stretch reminder to Telegram instead of a local file.

Create a Telegram bot

Telegram bots are lightweight accounts that can send and receive messages programmatically. You'll create one to act as Hermes' voice on Telegram.

If you don't have Telegram yet, download it from telegram.org and create an account.
Open Telegram and type @BotFather in the search bar at the top.
Tap on BotFather to open a chat with it.
Send /newbot as a message.
BotFather asks for a display name. Type a name like Hermes Agent and send it.
BotFather asks for a username. This must end in bot and be unique across all of Telegram. Try something like my_hermes_bot and send it.
BotFather replies with your bot's API token. Copy this token and save it somewhere safe. It looks like 123456789:ABCdefGHIjklMNOpqrSTUvwxYZ.

Keep your bot token safe

Anyone with your bot token has full control over your bot. Don't share it publicly or commit it to a repository.

Now you need your Telegram user ID so Hermes knows who is allowed to talk to your bot.

Search for @userinfobot in Telegram and open a chat with it.
Send any message. It replies with your numeric user ID. Save this number alongside your bot token.

What are the bot token and user ID for?

The bot token lets Hermes send and receive messages through your Telegram bot. The user ID tells Hermes which Telegram account is allowed to interact with it, so strangers can't control your agent.

Configure the gateway and connect

The Hermes messaging gateway is the bridge between your agent and external messaging platforms. It handles receiving your messages from Telegram and delivering cron output back to you.

Run the interactive setup wizard by entering this command in your terminal:

hermes gateway setup

What does the setup wizard ask?

The wizard walks you through configuring a messaging platform step by step. It prompts you to select a platform (choose Telegram), then asks for your bot token and your user ID. These values get saved to your Hermes configuration.

Select Telegram when prompted for the platform.
Paste your bot token when asked.
Enter your numeric user ID when asked.

With the gateway configured, start it up. The gateway runs in the foreground, which means it takes over the terminal window.

Start the gateway by running:

hermes gateway

Why does the gateway take over my terminal?

The gateway process runs in the foreground so you can see logs and connection status. It also ticks the cron scheduler every 60 seconds, which is how your scheduled jobs actually fire. You'll need to open a new terminal tab or window for any further commands.

Open a new terminal tab or window. Keep the gateway running in the original terminal.
Go back to Telegram and send any message to your bot.

Your bot should reply. If it does, your gateway is working and Hermes can now communicate through Telegram.

Bot not responding?

Make sure the hermes gateway process is still running in your other terminal. If it stopped or showed an error, check your bot token is correct.
Confirm your user ID is correct. You can re-check by messaging @userinfobot on Telegram again.
Re-run hermes gateway setup to fix any typos in the configuration, then restart the gateway.
Help me troubleshoot my Hermes Telegram gateway connection.

Set the home channel and deliver your reminder

Before Hermes can deliver cron output to Telegram, it needs to know which chat to send messages to. You set this by marking your direct conversation with the bot as the "home channel."

In Telegram, open your chat with your bot.
Send /sethome as a message to your bot.

What is the home channel?

The home channel is where Hermes sends cron output when a job is set to deliver to Telegram. By sending /sethome in your DM with the bot, you're telling Hermes to deliver to that specific conversation.

Now create a new cron job that delivers to Telegram. You already have the local-only stretch-reminder from Step 3. This time you'll create a fresh job with Telegram delivery baked in.

In your new terminal window, create the Telegram-enabled cron job by running:

hermes cron create "every 30m" "Remind the user to take a break and stretch. Include the current time and a motivational quote." --name "stretch-telegram" --deliver telegram

What does this command do?

"every 30m" sets the schedule to run every 30 minutes.
The quoted prompt tells the agent what to generate each time the job fires.
--name "stretch-telegram" gives the job a human-readable name so you can reference it by name instead of a hex ID.
--deliver telegram tells Hermes to send the output to your Telegram home channel instead of saving it locally.

Before you trigger this job, think about what will happen differently compared to when you ran stretch-reminder in Step 3. Where did that output end up, and where should this one go?

Trigger the job now by running:

hermes cron run stretch-telegram

Check your Telegram. Within a few seconds, you should see a message from your bot containing a stretch reminder, the current time, and a motivational quote.

That's the gap from Step 3 closed. Your cron output now reaches you on your phone instead of sitting in a file nobody reads.

Don't see a message in Telegram?

Confirm the gateway process is still running in its terminal window. The cron scheduler only ticks when the gateway is active.
Check that you sent /sethome to your bot before triggering the job. Without a home channel, Hermes doesn't know where to deliver.
Verify the job was created with Telegram delivery by running hermes cron list and checking the delivery column for your stretch-telegram job.
Help me troubleshoot why my Hermes cron job isn't delivering to Telegram.

Your agent now reaches you proactively on Telegram. Next up, you'll explore the Journey graph to see a visual timeline of everything Hermes has learned about you.

Explore Your Journey Graph

Your agent remembers who you are, runs tasks on a schedule, and delivers reminders straight to Telegram. But you have no way to see the full picture of everything Hermes has actually learned about you.

The Journey graph solves that. It plots every memory entry and skill your agent has accumulated into a constellation timeline, from oldest to newest. In this step, you'll open the graph, inspect individual nodes, and create one more cron job to watch the timeline grow.

In this step, get ready to:

Open the Journey graph and view the animated timeline.
List and inspect individual memory nodes.
Create a morning brief cron job and watch new nodes appear.

Open the Journey graph

The Journey graph is a built-in visualization that shows everything your agent knows. Each point on the timeline represents a memory entry or a skill Hermes created during your conversations.

Before you run the next command, what do you expect to see? Think about the information you shared with Hermes in the previous step.

Open the Journey graph by running this command in your terminal:

hermes journey

You should see a constellation timeline with nodes plotted from oldest at the top to newest at the bottom. Each node represents a memory chunk or skill from your earlier conversations.

What does this show?

The Journey graph pulls from two sources. Memory entries come from MEMORY.md and USER.md (the files Hermes wrote when you taught it about yourself). Skills are reusable procedures Hermes creates when it learns a new workflow.

Together, these nodes form a visual map of your agent's accumulated knowledge.

Watch the animated build-up of your Journey by running:

hermes journey --play

This replays how your agent's knowledge grew over time, adding each node one by one. You should see nodes appear sequentially from your earliest conversation to the most recent.

Journey in the TUI

If you're in the interactive TUI (running hermes with no subcommand), you can also open the Journey graph with the /journey command. It opens as an overlay right inside the terminal session.

Don't see any nodes?

Make sure you had conversations with Hermes in Step 2 where you shared your name, projects, and preferences. The memory entries from those conversations are what populate the Journey graph.

You can also check that your memory files exist by running cat ~/.hermes/memories/MEMORY.md. If the file is empty, return to the Chat tab and share some details about yourself.

Why is my Journey graph empty?

List and inspect nodes

The timeline gives you the big picture. Now let's drill into individual nodes to see exactly what Hermes stored.

List every node in your Journey by running:

hermes journey list

You should see a list of node IDs, one for each memory entry and skill. Each ID is a short identifier you can use to inspect, edit, or remove individual nodes.

Pick any node ID from the list.
Inspect its content by running:

hermes journey edit [[NODE_ID="a node ID from hermes journey list"]]

This opens the node's content in your default text editor. You can read through what Hermes stored, and make edits if anything looks off. Save and close the editor when you're done.

What can you do with nodes?

The hermes journey edit command opens the node in your $EDITOR (usually vi or nano on Linux). You can fix a fact Hermes got wrong, add detail it missed, or just read what it stored.

You can also remove nodes you no longer need with hermes journey delete. Skills get archived and can be restored later. Memory chunks are removed permanently.

Editor not opening?

If you see a "command not found" error, your $EDITOR environment variable may not be set. Most Linux systems fall back to vi, but you can set it explicitly by running export EDITOR=nano before trying again.

Why can't hermes journey edit open my node?

Add a daily brief and watch the Journey grow

Every time you create a new cron job or have a conversation, the Journey graph gains new nodes. Let's create one more scheduled task to round out your command center and see the timeline expand in real time.

Switch back to the dashboard's Chat tab (or your terminal running hermes).
Send this message to create a daily morning brief:

Every morning at 9am, check what I have on my plate based on your memory of my projects and send me a morning brief on Telegram.

How does Hermes handle this?

When you describe a scheduled task in natural language, Hermes uses its built-in cronjob tool to create the job automatically. It parses your schedule ("every morning at 9am"), writes the prompt, and sets the delivery channel to Telegram.

Each cron job runs in a completely fresh session with no conversation history. The prompt must be self-contained. That's why the message says "based on your memory" instead of referencing something from this chat.

Verify the job was created by running:

hermes cron list

You should see a new job alongside your existing stretch reminder jobs. The new job has a daily schedule and Telegram delivery.

Don't see the new job?

If hermes cron list only shows your stretch reminder jobs, Hermes may not have understood your message as a cron request. Try rephrasing with an explicit schedule. You can also create the job directly from the CLI:

hermes cron create "every day at 9am" "Check what the user has on their plate based on your memory of their projects and preferences. Send a morning brief summarizing their priorities for the day." --name "morning-brief" --deliver telegram

Why didn't Hermes create my cron job from natural language?

Before you open the Journey graph again, how many new nodes do you think have appeared since you last checked?

Open the Journey graph again by running:

hermes journey

Your timeline has grown. You should see new nodes at the bottom of the graph from the morning brief job creation. Every future conversation and cron run adds more nodes to this constellation.

Timeline looks the same?

If you don't see new nodes, make sure the morning brief job was successfully created by checking hermes cron list. The Journey graph updates when Hermes creates new skills or modifies memory during conversations.

Why doesn't my Journey graph show new nodes?

Secret mission

Chain Two Cron Jobs

Your cron jobs so far are standalone. Each one fires, does its thing, and that's it. In this secret mission, you'll build a two-stage pipeline where one cron job's output feeds the next. A collector gathers raw data, then a summarizer receives that data as context and produces a polished brief delivered straight to Telegram.

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. Your cron jobs consume LLM tokens each time they fire, so recurring jobs have an ongoing cost that depends on your provider and how frequently they run.

Cost warning

Each cron job run sends a prompt to your LLM provider and consumes tokens. A 30-minute reminder on a cheap model costs fractions of a cent per run, but the cost adds up if you leave multiple jobs active around the clock.

If you are not actively using the reminders, choose Pause or Delete below to stop token usage.

Resources you used:

Cron jobs (stretch-reminder, stretch-telegram, morning-brief): each run uses LLM tokens from your configured provider.
Telegram bot: free, no ongoing cost.
Hermes messaging gateway: runs in the background, no cost itself.
Cron output files in ~/.hermes/cron/output/: local storage only, no cost.

Keep everything running

No action needed. Choose this if you are still actively building and want your cron jobs to keep firing on schedule.

Your cron jobs will continue running as long as the gateway is active.
To keep cron jobs running even after you close the terminal, install the gateway as a system service by running:

hermes gateway install
hermes gateway start

Once installed as a service, the gateway starts automatically on boot and your cron jobs fire on schedule in the background.

Your memory files in ~/.hermes/memories/ and Journey graph data persist across sessions.

Pause - I'll come back to this later

Stop the gateway to prevent cron jobs from firing and consuming tokens. Your memory, Journey graph, and cron job definitions all persist.

If you installed the gateway as a service, stop it by running:

hermes gateway stop

If the gateway is running in the foreground in a terminal window, press Ctrl+C to stop it.
If the dashboard is still running in another terminal, press Ctrl+C in that window too.
When you are ready to resume, run hermes gateway (or hermes gateway start if installed as a service) and your cron jobs pick up where they left off.

Delete - I don't want to use this again

Remove all project resources and start fresh. Your memory and Journey graph persist regardless of what you delete here.

Remove the cron jobs you created during this project by running:

hermes cron remove stretch-reminder
hermes cron remove stretch-telegram
hermes cron remove morning-brief

Did you complete the Secret Mission?

If you created the chained cron jobs, remove those too:

hermes cron remove ai-news-collect
hermes cron remove ai-news-brief

Stop the gateway. If it is running in the foreground, press Ctrl+C. If installed as a service, run:

hermes gateway stop

If the dashboard is still running, press Ctrl+C in its terminal window.
Delete the cron output files by running:

rm -rf ~/.hermes/cron/output/

To delete your Telegram bot, open your chat with @BotFather on Telegram and send /deletebot. Select the bot you created for this project and confirm. This action cannot be undone.

What about your memory and Journey data?

Your memory files in ~/.hermes/memories/ and Journey graph persist even after removing cron jobs and the gateway. They carry over to any future Hermes sessions.

If you want to wipe them too, delete the memory files:

rm ~/.hermes/memories/MEMORY.md
rm ~/.hermes/memories/USER.md

That's a Wrap!

Nice work. You just built a personal AI command center that remembers who you are, runs tasks on autopilot, and reports back to you on Telegram.

You've learned how to:

Teach Hermes Agent about your projects and preferences, creating persistent memory entries in MEMORY.md and USER.md that carry across every future session.
Hit the limitation of local-only cron output, then solve it by connecting Telegram as a delivery channel via the Hermes messaging gateway.
Explore the Journey graph, a visual constellation timeline of everything your agent has learned and every skill it has created.
Secret Mission: Chain two cron jobs with context_from, building a multi-stage pipeline where one job's output feeds the next.

Ready to quiz yourself?