Self-Improving Content Pipeline

Build an overnight content pipeline that drafts posts and improves itself.

Introduction

30 Second Summary

Creating social media content every day is a grind. You know your voice and your audience, but translating that into consistent posts across multiple channels takes real time. What if you could teach a writing assistant your exact style, have it draft posts while you sleep, and watch it genuinely improve based on your edits?

In this project, you will build a self-improving content pipeline using Hermes Agent. You'll create custom skills for two content channels, schedule overnight drafting jobs that deliver to Telegram each morning, and trigger the agent's closed learning loop so it rewrites its own playbook based on your feedback.

What You'll Build

A self-improving content drafting pipeline that runs overnight, delivers ready-to-review social media drafts to your Telegram each morning, and autonomously patches its own writing instructions after every round of feedback.

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

  • Two custom content skills that encode your distinct voice for AI/Neural and Travel/Nature/Life channels.
  • Two scheduled cron jobs that autonomously draft content overnight and deliver to dedicated Telegram topics each morning.
  • A working self-improvement loop where Hermes patches its own skills after your feedback, getting measurably better without you editing config files.
  • Secret Mission: Gate the loop with write approval so you can inspect every skill patch before it lands, and offload the background review to a cheaper model.

Are there any prerequisites?

This project assumes you already have Hermes Agent installed and running on Windows with PowerShell 7.6, your Telegram gateway connected and working, and Anthropic API configured as your provider.

Tune Hermes for Observability

The self-improvement loop in Hermes runs silently by default. The background review evaluates your feedback, decides whether to patch skills, and moves on without telling you what it did.

In this step, you'll make the learning loop visible. You'll create dedicated Telegram topics to organize cron deliveries and configure Hermes to surface every memory and skill change as it happens.

In this step, get ready to:
  • Create two Telegram forum topics for organized cron delivery.
  • Configure Hermes memory notifications to verbose mode.
  • Verify the cron scheduler and Telegram targets are accessible.
Create dedicated Telegram cron topics

Cron jobs in Hermes deliver output to Telegram, but without organization, AI drafts and life drafts all land in the same conversation. Forum topics let you separate deliveries into distinct channels you can review independently.

  • Open the Telegram group where your Hermes bot delivers messages.
  • Create a new topic named AI Content.
  • Create a second topic named Life Content.

How do I create a Telegram topic?

In your Telegram group, tap the group name at the top to open group info. If Topics are enabled, you'll see a list of existing topics and an option to create a new one. Name your topic and confirm. If you don't see Topics, your group admin needs to enable them under group settings.

Now you need the thread ID for each topic so Hermes can target deliveries to the correct one.

  • Open the AI Content topic and send any message (even a simple "test").
  • Right-click (desktop) or long-press (mobile) the message you just sent.
  • Select Copy Message Link.
  • Paste the link somewhere. It will look like https://t.me/c/1234567890/25/33 where the second number (25 in this example) is your thread ID.
  • Note this thread ID for the AI Content topic.
  • Repeat the same process for the Life Content topic and note its thread ID.

What is this thread ID for?

Hermes uses the delivery target format telegram:<chat_id>:<thread_id> to send cron output to a specific forum topic. You'll plug these IDs into your cron jobs in a later step.

Don't see a Topics option?

Forum topics are only available in Telegram groups, not in direct messages with a bot. If you're chatting with Hermes in a DM, create a new group, add your Hermes bot to it, then enable Topics in the group settings.

help me set up a Telegram group with Topics enabled for Hermes cron delivery

Configure memory notifications to verbose

By default, Hermes shows a brief notification when memory or skills change. Verbose mode expands these notifications to show the exact content being saved or patched. This is how you'll observe the learning loop firing in real time.

  • Open ~/.hermes/config.yaml in your text editor.
  • Find or add the following sections, updating them to match this configuration:
# Persistent memory settings
memory:
  memory_enabled: true
  user_profile_enabled: true
  memory_char_limit: 2200
  user_char_limit: 1375
  write_approval: false

# Skill write behavior
skills:
  write_approval: false

# Surface all memory and skill changes in real time
display:
  memory_notifications: verbose

# Background review model (uses main chat model by default)
auxiliary:
  background_review:
    provider: auto
    model: auto

What does this configuration do?

  • memory_enabled: true and user_profile_enabled: true keep both persistent memory files active. MEMORY.md stores facts about you. USER.md stores your preferences and profile.
  • memory_char_limit: 2200 and user_char_limit: 1375 are the defaults. Keeping them explicit ensures nothing unexpected overrides them.
  • display.memory_notifications: verbose is the key change. Instead of a brief icon, you'll see exactly what the background review is saving or patching after each turn.
  • skills.write_approval: false lets the agent write skills freely for now. You'll gate this in the Secret Mission later.
  • auxiliary.background_review set to auto means the background review runs on the same model as your main chat (your Anthropic provider).
  • Save ~/.hermes/config.yaml.

Unsure where to put these sections?

Your existing config.yaml likely has other sections (providers, Telegram credentials, etc.). Add the memory, skills, display, and auxiliary blocks anywhere at the top level of the file. If any of these keys already exist, update their values to match rather than duplicating the section.

help me update my Hermes config.yaml to add the memory, skills, display, and auxiliary sections

✔️ Awesome, I've got everything!

Great. Make sure you've saved the file before moving on.

ⓧ I'd like to double check the full code

Here's what the relevant sections of your config.yaml should look like:

memory:
  memory_enabled: true
  user_profile_enabled: true
  memory_char_limit: 2200
  user_char_limit: 1375
  write_approval: false

skills:
  write_approval: false

display:
  memory_notifications: verbose

auxiliary:
  background_review:
    provider: auto
    model: auto
Verify your setup

Before building on top of the scheduler and Telegram delivery, confirm both are responding correctly. These two commands test the plumbing.

  • Confirm the cron scheduler is accessible by running this command:
hermes cron list
  • You should see an empty list or any previously scheduled jobs. The command returning without error confirms the scheduler is running.
  • Verify your Telegram targets are discoverable by running:
hermes send --list telegram
  • You should see your configured Telegram targets listed in the output. This confirms Hermes can reach your Telegram delivery endpoints.

Seeing an error from either command?

If hermes cron list fails, check that the Hermes agent process is running. Restart it if needed.

If hermes send --list telegram returns no targets, verify that your Telegram credentials are configured in ~/.hermes/.env and that your bot token is valid.

help me troubleshoot why hermes cron list or hermes send --list telegram is failing

Your Hermes is now configured for full observability. Next up, you'll teach it two distinct content voices using the skills system.

Create Your Content Skills with /learn

Your Hermes environment is tuned for observability. Now it's time to teach the agent how you write.

Hermes separates "what it knows about you" (memory) from "how to do something" (skills). Memory is like your diary: always in context, compact. Skills are like recipe cards: loaded on demand, with detailed procedures. In this step, you'll create two recipe cards for your two content voices.

In this step, get ready to:
  • Create the AI/Neural content skill using /learn.
  • Create the Travel/Nature/Life content skill using /learn.
  • Inspect and refine your skills to trigger a skill patch.
Create the AI/Neural content skill

The /learn command takes a description of what you want Hermes to know how to do and creates a SKILL.md file in ~/.hermes/skills/. The agent authors the skill following its internal format (sections like Procedure, Pitfalls, and Verification) so you never have to write config by hand.

  • Teach Hermes your AI/Neural content voice by sending this message in your Hermes conversation (Telegram or CLI chat):
/learn My AI/Neural social media content style: I write short-form posts about the intersection of neural science and machine learning. Tone is curious and exploratory, not academic. I use metaphors to make abstract concepts tangible. I cover topics like how transformers mirror biological attention, how agent loops resemble habit formation, how weight updates parallel synaptic plasticity. Target audience: AI practitioners who appreciate the biological parallels. Format: 1-3 paragraphs, punchy opening hook, one takeaway. Never use hashtags in the body text.

What does /learn do?

The /learn command accepts sources like a text description, URL, or directory path. Hermes reads the input and authors a full SKILL.md that captures the procedure.

Skills are different from memory. Memory is compact (2,200 chars max) and always injected into the system prompt. Skills are loaded on demand when invoked, so they can hold detailed, lengthy procedures without eating into your context window.

  • Wait for Hermes to confirm the skill was created. Note the slash command name it assigns (likely /ai-neural-content or similar).
  • Test the skill by sending the assigned slash command in your conversation. Hermes should acknowledge it loaded the skill context.

Skill not created?

Make sure your message starts with /learn followed by a space. If Hermes treats it as a regular message instead of a command, try starting a new conversation.

If Hermes acknowledges the command but produces an error, check that skills.write_approval is set to false in your config. With approval enabled, the skill would be staged instead of created directly.

help me troubleshoot why /learn isn't creating my skill

Create the Travel/Nature/Life content skill

Now you'll teach Hermes a completely different voice for your second channel.

  • Send this message in your Hermes conversation to create the second skill:
/learn My Travel/Nature/Life social media content style: I write reflective, sensory posts about places, nature, and personal growth. Tone is grounded and unhurried. I focus on small observations that reveal larger truths. Topics: travel moments, nature encounters, reading insights, journaling reflections, life philosophy. Format: short narrative vignettes, 2-4 paragraphs. Open with a specific moment or image, not an abstraction. Close with something the reader can sit with. No listicles, no "tips."

Why two separate skills instead of one?

Each skill encodes one voice with one procedure. Keeping them separate means the cron jobs you'll create next can load exactly the voice they need without confusing the two styles.

It also means the background review can patch each skill independently. If your AI content feedback says "more concrete examples" that correction updates only the AI skill, leaving your Travel voice untouched.

  • Wait for Hermes to confirm the second skill was created. Note the assigned slash command name (likely /travel-nature-life or similar).
  • Test it by sending the assigned slash command. Hermes should acknowledge the skill loaded.

Getting a different skill name than expected?

Skill names are assigned by the agent during /learn. The exact name depends on what Hermes derives from your description. Whatever name it assigns is fine. Just note it down so you can reference it in later steps.

help me find what skill names Hermes assigned after running /learn

Inspect and refine your skills

The skill files Hermes created capture your description, but they might not be perfect on the first pass. You can view the full content and give feedback to trigger an improvement. This is the same mechanism the background review uses autonomously. You're doing manually what the agent will later do on its own.

  • View the full content of your AI/Neural skill by running this command in your terminal:
hermes chat --toolsets skills -q "Show me the ai-neural-content skill"

What does this command do?

The --toolsets skills flag gives Hermes access to the skills toolset for this one-shot query. The -q flag sends a single question and returns the answer without entering interactive chat mode.

Hermes uses progressive disclosure for skills. The skills_list() function gives a compact overview. The skill_view(name) function shows the full SKILL.md content. Asking Hermes to "show" a skill triggers the full view.

  • Read through the Procedure section. Check that it captures your voice accurately.
  • Now refine the skill by sending this feedback in your Hermes conversation:
In the AI content skill, I also want you to always include a specific real-world example. Update the skill.

What happens when you give this feedback?

Hermes triggers a skill_manage patch action. This modifies the existing SKILL.md rather than recreating it from scratch. You should see a verbose memory notification confirming the skill was patched.

This is the exact same mechanism the background review uses after your feedback sessions. The difference is that right now you're giving the instruction explicitly. Later, the agent decides on its own whether feedback warrants a skill update.

  • Confirm the patch landed by running the inspection command again:
hermes chat --toolsets skills -q "Show me the full content of the ai-neural-content skill"
  • Look for "Always include a specific real-world example" (or similar wording) in the Procedure section. This confirms the skill_manage patch action worked.

Use the actual skill name Hermes assigned

If Hermes assigned a different name than ai-neural-content, substitute the actual name in the commands above. You can always check your full list by asking Hermes "What skills do you have?" in conversation.

Don't see the patch notification?

Make sure display.memory_notifications is set to verbose in your ~/.hermes/config.yaml. If you changed it after starting the session, restart Hermes for the config to take effect.

If the skill content didn't change, try being more direct. Say "Update the ai-neural-content skill Procedure section to include: Always include a specific real-world example." Explicit instructions make it clear you want a skill edit, not just a conversation reply.

help me troubleshoot why my skill refinement feedback didn't trigger a patch

Both your content voices are now encoded as skills that Hermes can load on demand. Next up, you'll wire these skills to the cron scheduler so they run autonomously overnight and deliver drafts to your Telegram topics each morning.

Schedule Overnight Cron Jobs

Your content skills are ready. Each one encodes a distinct voice and style that Hermes can follow on demand.

Now you'll wire these skills to the cron scheduler so they fire autonomously overnight and deliver finished drafts to your Telegram topics each morning. The cron system runs jobs in completely fresh sessions with no memory of prior conversations, so your prompts need to be self-contained. The attached skills provide the procedural context the agent needs.

In this step, get ready to:
  • Create the AI/Neural content cron job with a daily 6:00 AM schedule.
  • Create the Travel/Nature/Life content cron job with a daily 6:30 AM schedule.
  • Test both jobs and confirm delivery to the correct Telegram topics.
Create the AI/Neural content cron job

Hermes uses standard 5-field cron expressions for scheduling. The expression 0 6 * * * means "at minute 0 of hour 6, every day." Natural language like "daily at 6am" is not supported.

  • Create the AI content cron job by running this command:
hermes cron create "0 6 * * *" "Draft one social media post for my AI/Neural channel. Search the web for one interesting recent development in AI or neural science from the past 48 hours. Apply the content style and format from the skill. Output ONLY the finished post text, ready to copy-paste." --name "AI content draft" --skill ai-neural-content --deliver telegram:[[AI_TOPIC_TARGET="your-chat-id:your-AI-Content-thread-id"]]

What does this command do?

  • hermes cron create registers a new scheduled job with the Hermes scheduler.
  • "0 6 * * *" sets the schedule to 6:00 AM every day.
  • The quoted prompt string is what the agent receives when the job fires. It must be self-contained because cron sessions have no memory of your prior chats.
  • --skill ai-neural-content attaches your AI content skill, giving the agent your voice and format instructions.
  • --deliver telegram:<chat_id>:<thread_id> sends the output directly to your AI Content Telegram topic. No gateway needs to be running at delivery time.

Finding your thread IDs

You noted the thread IDs for your AI Content and Life Content topics back in Step 1. The delivery target format is telegram:<chat_id>:<thread_id> where both values come from the topics you created. If you didn't note them, run hermes send --list telegram to see your available targets.

  • Confirm the job was created by running:
hermes cron list

You should see your "AI content draft" job with status "scheduled" and the cron expression 0 6 * * *.

Job not appearing in the list?

  • Check that your cron expression is wrapped in quotes. Without quotes, the shell may interpret the asterisks as wildcards.
  • Verify the skill name matches exactly. Run hermes chat --toolsets skills -q "What skills do you have?" to see the assigned names.

Help me troubleshoot why my cron job wasn't created

Create the Travel/Nature/Life content cron job

You'll stagger this job 30 minutes after the first to avoid overlap. The cron expression 30 6 * * * means "at minute 30 of hour 6, every day."

  • Create the Life content cron job by running this command:
hermes cron create "30 6 * * *" "Draft one social media post for my Travel/Nature/Life channel. Draw from universal travel and nature themes, seasonal observations, or timeless life wisdom. Apply the content style and format from the skill. Output ONLY the finished post text, ready to copy-paste." --name "Life content draft" --skill travel-nature-life --deliver telegram:[[LIFE_TOPIC_TARGET="your-chat-id:your-Life-Content-thread-id"]]

What's different here?

  • The schedule is 30 6 * * * instead of 0 6 * * *. Staggering by 30 minutes gives each job a clean window to complete without competing for API credits.
  • The --skill flag attaches travel-nature-life instead of ai-neural-content. Each job gets the procedural voice for its channel.
  • The --deliver target points to your Life Content Telegram topic.
  • Confirm both jobs are registered by running:
hermes cron list

You should now see two jobs: "AI content draft" at 0 6 * * * and "Life content draft" at 30 6 * * *. Both should show status "scheduled."

Seeing an error about the schedule format?

Hermes only accepts standard 5-field cron expressions, relative delays (like 30m, 2h), intervals (like every 2h), or ISO timestamps. Natural language like "daily at 6:30am" is not supported.

Help me fix my cron schedule expression

Test both jobs immediately

You don't need to wait until 6 AM tomorrow. The hermes cron run command triggers a job on demand so you can verify the output right now.

  • Find the job IDs from your hermes cron list output. Each job has a unique ID in the first column.
  • Trigger the AI content job by running:
hermes cron run [[AI_JOB_ID="your-AI-content-draft-job-id"]]
  • Trigger the Life content job by running:
hermes cron run [[LIFE_JOB_ID="your-Life-content-draft-job-id"]]
  • Switch to Telegram and check both forum topics.
  • In the AI Content topic, you should see a drafted social media post about a recent AI or neural science development.
  • In the Life Content topic, you should see a reflective vignette about travel, nature, or personal growth.

What if the output doesn't match your style?

The drafts might not be perfect on the first run. That's expected. In the next step, you'll give targeted feedback and watch Hermes rewrite its own skills based on your corrections. The learning loop is the whole point of this pipeline.

No message in your Telegram topic?

  • Verify your delivery target format. Run hermes send --list telegram to see discoverable targets and confirm your chat ID and thread ID are correct.
  • Check that your Telegram bot token is configured in ~/.hermes/.env. No gateway process needs to be running. Hermes calls the Telegram REST endpoint directly using credentials in that file.
  • Re-run the job and watch the terminal output for error messages about delivery failures.

Help me debug why my cron job isn't delivering to Telegram

Your autonomous content pipeline is now scheduled and confirmed. Both jobs will fire every morning and deliver ready-to-review drafts without any manual intervention. Next up, you'll give feedback on these drafts and watch Hermes rewrite its own skills in response.

Trigger the Learning Loop

Your cron jobs are scheduled and delivering drafts to Telegram each morning. Now comes the moment that separates Hermes from every other scheduling tool: you're going to give feedback and watch the agent rewrite its own playbook.

Most AI workflows treat the model as a static tool. You prompt, it responds, nothing compounds. Hermes' background review watches your corrections, detects patterns, and autonomously patches the skill that produced the output.

In this step, get ready to:
  • Give targeted feedback on the cron-delivered drafts via Telegram replies.
  • Observe the background review autonomously patching your skills.
  • Verify that your skill's Procedure section has evolved.
Give targeted feedback on the drafts

The cron jobs you tested in the previous step delivered draft posts to your Telegram topics. Those drafts are your starting material. By replying directly to a cron-delivered message, you continue that cron session and give the agent corrective signal it can learn from.

  • Open your Telegram app and navigate to the AI Content topic where your test draft was delivered.
  • Reply directly to the delivered draft message (long-press or swipe to reply on mobile, right-click on desktop).
  • Give specific, corrective feedback. Here are three examples you can adapt:
  • "This is too abstract. I need a concrete example in the opening line. Something the reader can picture."
  • "The closing is weak. It should leave a question, not state a conclusion."
  • "Good structure but wrong tone. This reads like a LinkedIn post. I want it more conversational, like explaining it to a friend over coffee."
  • Send your feedback and wait for Hermes to revise the draft.
  • Repeat in the Life Content topic with feedback relevant to that channel's voice.

Why reply to the message specifically?

Replying (not sending a new message) continues the cron session that produced the draft. This gives the background review the full context: the original prompt, the skill used, the draft produced, and your correction. A new standalone message wouldn't link back to the session.

Give directional feedback, not just ratings

"This is bad" teaches the agent nothing. "The opening is too abstract, start with a specific image" gives the background review a concrete rule to encode. The more specific your correction, the more likely it triggers a skill patch.

Observe the background review in action

Because you set memory_notifications to verbose in Step 1, Hermes will surface what the background review decides after processing your feedback.

  • After sending your feedback and receiving the revised draft, watch the Telegram conversation for a notification line that looks like:
  • 💾 Skill ai-neural-content patched
  • If you don't see a notification after your first round of feedback, give more feedback on the revised draft. The agent needs to observe a pattern (repeated corrections in the same direction) before it commits a skill change.

Why doesn't every correction trigger a patch?

The background review distinguishes one-off preferences from durable lessons. A single correction might be situational. Two or three corrections in the same direction signal a real pattern worth encoding.

This mirrors how memory consolidation works: not every experience becomes long-term memory. Only repeated or high-salience signals get committed.

Not seeing any skill patch notification?

Make sure you're replying to the cron-delivered message, not sending a standalone message in the topic. The background review needs the session context to evaluate your feedback.

Try giving 2-3 rounds of feedback that push in the same direction (e.g. "more concrete", "still too abstract", "closer but give me a specific example"). Consistent corrections are more likely to trigger a patch than a single isolated comment.

Confirm display.memory_notifications is set to verbose in your ~/.hermes/config.yaml. If it's set to on or off, patches still happen but notifications won't be visible.

help me debug why the background review isn't patching my skill after feedback

Verify the skill evolved

Once you see the patch notification, it's time to confirm the skill actually changed. You'll inspect the same skill you reviewed in Step 2 and compare its Procedure section to what was there before.

  • View the full content of your AI content skill by running this command:
hermes chat --toolsets skills -q "Show me the full content of the ai-neural-content skill"

What does this command do?

The --toolsets skills flag gives the agent access to the skills toolset so it can read your skill files. The -q flag passes a single query and exits, so you get a quick answer without entering an interactive chat session.

  • Compare the Procedure section to what you saw when you first created the skill. Look for new lines the agent added based on your feedback.

Your skill's Procedure section should now contain new rules that reflect your corrections. The agent didn't just remember what you said. It rewrote its own instructions.

What kind of changes should I see?

If you told the agent to use concrete openings, you might see a new line like "Opening line must be concrete and picturable, not abstract." If you pushed for questions instead of conclusions, you might see "Closing should pose a question rather than state a conclusion."

The exact wording depends on your feedback. The key observation is that the Procedure section is longer and more specific than when you authored it with /learn.

Skill looks unchanged?

If the Procedure section looks identical to what you created in Step 2, the background review may not have fired yet. Return to your Telegram topic, give another round of specific feedback, and wait for the patch notification before re-running this command.

Also check that skills.write_approval is set to false in your config. If it's true, patches are staged instead of committed. You'd need to approve them with /skills approve first.

help me figure out why my skill hasn't been updated by the background review

Secret mission

Gate, Inspect, and Optimize the Loop

You've seen the self-improvement loop work autonomously. Now put guardrails on it. In a team setting, you'd want to review every skill patch before it lands. You'll gate writes with approval, bundle both skills into a single command, and offload the background review to a cheaper model.

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. Each cron job fires one agent session per day using your Anthropic credits, adding a few cents per run.

Cost warning

Your two cron jobs consume Anthropic tokens each time they fire (once per day each). The background review also uses tokens when it evaluates feedback. If you're not actively reviewing and refining drafts, pause or remove the jobs to stop the token spend.

Resources you used:

  • Two SKILL.md files in ~/.hermes/skills/ (local files, no ongoing cost).
  • Two cron jobs in the Hermes scheduler (ongoing Anthropic token cost per run).
  • One skill bundle YAML at ~/.hermes/skill-bundles/content-pipeline.yaml (local file, no ongoing cost).
  • Configuration changes in ~/.hermes/config.yaml (verbose notifications, write approval, background review model).

Keep everything running

No action needed. Choose this if you want the cron jobs to keep firing daily and your content pipeline to improve over time.

  • Your two cron jobs will deliver drafts to your Telegram topics each morning at 6:00 AM and 6:30 AM.
  • The background review will continue patching skills as you give feedback.
  • With skills.write_approval set to true, every patch is staged for your inspection before it lands.
  • Ongoing cost is a few cents per day in Anthropic tokens (two short agent sessions).

Pause - I'll come back to this later

Pause the cron jobs to stop daily token spend while keeping everything intact. You can resume at any time.

  • List your cron jobs and note the job IDs by running:
hermes cron list
  • Pause each job by running:
hermes cron pause <job_id>
  • Run this command once for the AI content draft job and once for the Life content draft job.
  • Your skill files, bundle, and config stay in place. No data is lost.
  • When you're ready to restart, resume with:
hermes cron resume <job_id>

Delete - I don't want to use this again

Remove all project resources and start fresh. This permanently deletes your skills, cron jobs, and bundle.

  • First, list your cron jobs to find the job IDs:
hermes cron list
  • Remove both cron jobs by running this command for each job ID:
hermes cron remove <job_id>
  • Delete the skill bundle:
hermes bundles delete content-pipeline
  • Delete both skill files:
rm ~/.hermes/skills/ai-neural-content.md
rm ~/.hermes/skills/travel-nature-life.md
  • Finally, revert your config changes. Open ~/.hermes/config.yaml and set these values back to their defaults:
skills:
  write_approval: false

display:
  memory_notifications: on

auxiliary:
  background_review:
    provider: auto
    model: auto
  • Save the file. Your Hermes installation is back to its pre-project state.

Nice Work!

Nice Work!

You just built a self-improving content pipeline powered by Hermes Agent. Every morning, two cron jobs draft social media posts in your voice, deliver them to Telegram, and get measurably better each time you give feedback.

You've learned how to:

  • Created custom content skills using /learn that encode distinct voices for separate channels.
  • Scheduled autonomous overnight cron jobs that draft content and deliver it to dedicated Telegram topics each morning.
  • Triggered the self-improvement loop and observed the agent autonomously patching its own skills based on your feedback.
  • Secret Mission: Gated skill writes with write_approval, created a skill bundle for both channels, and optimized cost by offloading the background review to a cheaper model.

Ready to quiz yourself?