Week 4 of 6
Agentic Creativity
Long-Running Agents and How They Change Over Time
Live on Zoom · 2.00–4.30pm ET
13 September 2026
Derrick Schultz
Course schedule
Week 1 · Aug 16
Introduction to agentic creativity and Hermes Agent setup
Week 2 · Aug 23
Models, text generation, and everyday tasks
Week 3 · Aug 30
Skills, MCPs, and visual capabilities
Sep 6
No class
Week 4 · Sep 13
Long-running agents and how they change over time
Week 5 · Sep 20
An introduction to agentic coding
Week 6 · Sep 27
Show and tell
Today the agent gets two things: a memory that carries between sessions, and a job that keeps going after you close the laptop.
Today’s schedule
2.00
Homework check-in: your skill, your MCP, your scheduled job
2.15
Memory: what an agent carries between sessions, and where the field is going
2.55
Working without you: cron, goals, loops, and kanban boards
3.25
Break
3.30
Lab: set up a job that runs all week
3.55
Our class agent grows up
4.15
Homework and questions
Two weeks ago you scheduled a skill and an MCP together. What happened?
It ran
What did the first run produce? Was it what you asked for, or what you meant?
It broke
Auth expired, a tool call failed, the prompt forgot a path. Where did you find out?
It repeated itself
Every run starts from nothing. Did run three know what run two had already done?
You stopped looking
Honest answer. After how many days?
Three or four people share for two minutes each. The third row is today’s whole subject.
today’s question
What does an agent become when it keeps working after you leave?
Quick start: In the chat, how long did your scheduled job run before it did something you didn’t expect?
01
Memory
2.15–2.55 · 40 minutes
a useful definition
A long-running agent is one that carries something forward from one session to the next.
Not the whole conversation. Something smaller, chosen, and written down.
Four places an agent can keep things.
Session
This conversation. Everything you said and every tool result. Ends when you start a new one.
Memory files
MEMORY.md and USER.md. Small, curated, loaded into every session.
Files
A project folder, a private GitHub repo, or a Notion page. Unlimited, but only read when you or the prompt point at it.
Skills
Methods. Loaded when a matching task comes up. Week 3.
Week 2 treated memory as a setting. Today it’s the design problem: what belongs where?
The research sorts memory by the job it does, not by how long it lasts.
Factual
For consistency. Your preferences, your setup, the rules of the project. Hermes: USER.md, MEMORY.md.
Experiential
For learning. What worked last time, distilled into a method. Hermes: skills, and the ones it writes itself.
Working
For the task in front of it. Plans, half-results, what’s left. Hermes: the session, and whatever file it’s keeping notes in.
Hundreds of memory papers in 2025 alone. This split is from the survey that tried to sort them. · Memory in the Age of AI Agents (Dec 2025)
Four ideas, all of which are now inside Hermes.
MemGPT · 2023
Treat the context window like RAM and everything else like disk. Let the model page its own memory in and out. Became Letta.
Generative Agents · 2023
A memory stream plus reflection: every so often the agent reads its own log and writes conclusions. Honcho does this about you.
Sleep-time compute · 2025
A second agent tidies memory while nobody’s talking. Hermes’s background review and the curator.
Context engineering · 2025
Manus: use the file system as memory, keep a todo.md, rewrite it every step. Anthropic: a memory directory the agent reads before it starts.
None of this is exotic any more. The question for you is which of it to turn on.
~/.hermes/memories/
Memory is small on purpose.
MEMORY.md · the agent’s notes · 2,200 characters
Exports for the gallery screen are 3840×2160, sRGB, no watermark.
§
Dusk Index project lives in ~/projects/dusk-index; LOG.md is the source of truth.
# bad entries
User seemed happy with the poster today.
[a 400-word summary of Tuesday]
USER.md · who you are · 1,375 characters
Filmmaker. Works in Premiere and TouchDesigner. Prefers short replies; ask before spending over $2.
§
Eastern time. Available to review outputs in the evening.
# bad entries
Likes art.
About 800 and 500 tokens. When it’s full, Hermes has to consolidate or delete before it can add. That constraint is the feature. · Hermes: memory
the timing catch
Memory is loaded once, at the start of a session.
Anything Hermes saves mid-conversation is real, but the agent won’t act on it until the next session starts.
After an important correction, start a new session. /new is cheap.
This is why an agent can “remember” something and still ignore it for the rest of the afternoon.
system prompt + SOUL.md + AGENTS.md
+ memory snapshot (9am)
you: “always export 3840×2160”
memory add → saved to disk
system prompt still says 9am snapshot
/new → SESSION B
system prompt + SOUL.md + AGENTS.md
+ memory snapshot (now)
knows 3840×2160 from the first message
what it saves without asking
Hermes writes memory when you correct it, state a preference, or teach it a fact about your setup.
A background review also runs after each turn and can save quietly. You’ll see a small notice when it does.
Turn the notices on: display.memory_notifications: on. Watching it save is how you learn what it thinks matters.
No. The gallery screen is 3840×2160. It always is. Stop asking.
memory · add · “Gallery screen exports: 3840×2160, sRGB.”
Saved. Re-exporting the three stills now.
Also I hate the word “vibrant”.
memory · add to USER.md · “Avoid the word vibrant.”
you own the file
You can watch, approve, and edit what it remembers.
Approve every write
/memory approval on
/memory pending
/memory approve <id>or all
/memory reject <id>
# or in config.yaml
memory:
write_approval: true
See what it has learned over time
hermes journey
timeline of every memory + skill it saved
hermes journey edit <node>
hermes journey delete <node>
# or just open the files
open ~/.hermes/memories/
Turn approval on when the agent keeps saving wrong assumptions. Turn it off once you trust what it picks up.
The transcript isn’t memory. It also isn’t gone.
Every session is stored
Full text, in ~/.hermes/state.db. Unlimited. Never loaded automatically.
The agent can search it
Ask: “What did we decide about the poster colours in August?” It uses session_search and quotes the answer back.
You can too
hermes sessions list · hermes sessions rename · hermes sessions export notes.md
When a session gets long
/compress summarises the old part and keeps going. Older detail is still searchable.
Name your sessions. /new dusk-index now means hermes -c dusk-index works in October.
this month · GPT-6 Astra in Codex
The newest frontier model stopped summarising and started taking notes.
Every agent hits the end of its context window. The old fix is compaction: squash the conversation into one summary and continue. Each squash loses detail, and the next one squashes the summary.
Astra keeps a running notebook across windows, leaves the old windows searchable, and can call new_context to start clean instead of compacting.
Experimental, off by default, released 3 Sep 2026. Hermes has had the same shape for a while: MEMORY.md is the notebook, session_search is the archive, /new is the clean start.
new state = summarise(old summary + recent window)
errors compound; the summary is all you have
# notes + searchable history
new state = this window + notes + lookups
turn 2’s test result is still findable at turn 400
# three layers
active context what’s in front of it now
notes constraints, discoveries, dead ends, open work
archive every earlier message and tool result
the convergence
Every lab landed on the same answer: the agent writes things down, then reads them back.
Manus: the file system as memory. Anthropic: a memory directory and a progress file. OpenAI: notes across context windows. Hermes: MEMORY.md and a searchable transcript. Same idea, four wrappers.
Give every long project a log the agent keeps.
LOG.md
Dated entries, appended at the end of every session or job. What it did, what it decided, what it rejected and why, what’s still open.
plan.json
The checklist. Each item done: false until it’s verified, not until it’s attempted. JSON because models are less likely to casually rewrite it than Markdown.
START.md
How to begin. Where the files are, what finished looks like, what never to touch. The first thing it reads.
Pointers, not contents
Keep the URL and the file path in the log, not the page or the image. Anything with a pointer can be re-read. Anything summarised is gone.
Anthropic’s harness for week-long coding agents is exactly three files: claude-progress.txt, feature_list.json, init.sh. Its system prompt says: assume interruption. · Effective harnesses for long-running agents
where the log lives
Keep the log where you already look.
In the project folder or a private repo
Start every session by reading LOG.md and plan.json.
Before you finish, append a dated entry to LOG.md:
what you did, what you decided, what is still open.
Never delete earlier entries.
# a cron job that reads its own log
hermes cron create "daily at 7am" \
"Read ~/projects/dusk-index/LOG.md, do the next
open item in plan.json, append to LOG.md" \
--continuity
# the repo is the backup (Week 2)
git add LOG.md plan.json && git commit -m "day 4"
In Notion or a Google Doc
hermes skills → productivity/notion, google-workspace
# Notion: one page per project, append-only
export NOTION_API_KEY=ntn_…
share the page with the integration in Notion first
Append today’s LOG entry to the Dusk Index page.
# Google Docs
$GAPI docs append DOC_ID --text "…"
$GAPI drive upload out/selects.jpg --parent FOLDER_ID
# or any MCP from Week 3
/mcp add notion
Notion and Docs are for the log you read on your phone. The folder is for the log the agent reads. Do both: the file is the source of truth, the page is the mirror.
what it looks like
Read at the start, write at the end. That’s the whole discipline.
The agent doesn’t need to remember Tuesday. It needs to know where Tuesday is written down.
Ask for this in AGENTS.md once and it becomes a habit. Check the log on day 7 and you’ll read the project’s own account of itself.
/new dusk-index
read_file · ~/projects/dusk-index/LOG.md · plan.json
Last entry Tuesday 9pm: warm palette rejected, two stills still need regrading, the gallery asked for a 4K vertical crop. 3 of 8 plan items done. Start with the regrade?
Yes. Then the vertical crop.
…
append · LOG.md · “Thu 13 Sep. Regraded 04 and 07 (cooler, +0.3 stops). Vertical crop 2160×3840 in out/vertical/. Rejected: cropping from the master, too soft. Open: 4 items.”
notion · append to “Dusk Index” · same entry + links
ThereThere’s a market for memory now. Each product is a different bet on what it is.
rsquo;s a market for memory now. Each one is a different bet on what memory is.Mem0
Memory is facts about the user. Extracted automatically from every exchange, deduplicated, injected back. The most widely wired-in.
Zep
Memory is a graph with dates. Every fact has a window when it was true. Best when things change: addresses, clients, what a project is called this month.
Letta
Memory is blocks the agent edits itself. Descended from MemGPT. Built for agents that run for weeks.
Supermemory, Honcho, others
Fast search over everything you’ve said; a model of you that forms opinions; a dozen more. Benchmarks: LoCoMo, LongMemEval, BEAM.
A 92 on LoCoMo says nothing about your studio. What matters: does it recall the right thing, and what does each recall cost? About 7,000 tokens per query versus 26,000 for dumping the whole history. · State of agent memory 2026
hermes memory setup
Hermes plugs into nine of them. One at a time, alongside MEMORY.md.
Free and local
openviking a folder-shaped knowledge tree, three depths of detail. Self-hosted.
byterover extracts insights before compression so they survive it.
hindsight knowledge graph with a reflect tool. Local free, cloud paid.
# turn one on, check, turn off
hermes memory setup
hermes memory status
hermes memory off
Hosted, mostly paid
mem0 server-side fact extraction. Also open source.
supermemory semantic search, user profile, whole-session ingest.
retaindb seven memory types, $20/month.
memori pip install hermes-memori first.
# each one adds tools you’ll see in /tools list
auto-inject: it writes into your context every turn
tools-only: the agent has to choose to look
My advice for this class: none of them yet. Get MEMORY.md and a project log right first. Add a provider when you can name the thing it keeps forgetting. · Hermes: memory providers
optional · external memory
Honcho is a memory that forms opinions about you.
Built-in memory stores what you said. Honcho watches every exchange and writes its own conclusions about your preferences, habits, and goals. Those accumulate.
After a month it knows things you never told it. That’s the appeal and the problem.
Your messages are stored on Honcho’s servers by default. You can self-host, or skip it. · Hermes: Honcho
hermes memory setup
→ choose honcho → paste key from honcho.dev
hermes honcho status
hermes honcho mode hybrid | context | tools
# keep the cost down
dialecticCadence: 5
think about the user every 5 turns, not every 2
# delete a conclusion it got wrong
honcho_conclude delete_id
When your agent feels dumber than it did last week.
Wrong model
A provider changed underneath you. /model shows what’s actually running.
Full context
Long sessions degrade. /usage to check, /compress to fix, /new to start clean.
Stale snapshot
It saved the correction but hasn’t reloaded it. /new.
Lost a tool
A skill or MCP got disabled. /skills · /tools list · /reload-mcp
It’s almost never the model getting worse. It’s the context around it. · Hermes: “My agent feels dumber”
five-minute exercise
Ask your agent what it remembers about you.
1.Show me everything in MEMORY.md and USER.md.
2. Delete one thing that’s wrong or useless. There will be one.
3. Add one thing it should have known already. A format, a rule, a word you hate.
4./new, then check it acts on it.
In the chat: the strangest thing your agent had decided to remember.
02
Working without you
2.55–3.25 · 30 minutes
the week 2 problem
A scheduled prompt starts from nothing every time it runs.
That was fine for a digest. It’s useless for a project. Long-running work needs a thread.
four shapes of long-running work
Four ways to make an agent keep working.
cron
Runs on a clock
Fresh session every run. Survives restarts. Delivers to Telegram, Discord, email, or a folder. Week 2, plus a memory.
/goal
Runs until done
You state the finish line. A judge model checks after each turn and says continue, done, or blocked. One session, one objective.
/loop
Runs on a timer, in this chat
Re-runs a prompt every N minutes with the conversation intact. Dies with the session. /heartbeat is its passive cousin.
kanban
Runs a board of cards
Many tasks, many agents, dependencies between them. Survives restarts. You can see and edit every card.
Rule of thumb: after you close the laptop, it’s cron or kanban. Goal and loop live inside a session you’re sitting in.
the fix for the week 2 problem
Give a cron job a memory of its own.
Three ways to carry state between runs
hermes cron create "daily at 7am" "..." --continuity
# 2. it reads another job's output
context_from: ["gather-references"]
# 3. it reads and writes a file you name
"Read ~/projects/dusk/LOG.md first.
Append what you made to it when done."
And one way to stay quiet
"If no new output is worth my time,
reply only with [SILENT]."
delivery is skipped · output still saved to
~/.hermes/cron/output/<job>/
The file is the most reliable of the three. It’s also the one you can open and read yourself. · Hermes: cron
example · a daily image job
Each run picks up where the last one stopped.
The log is the thread. The agent reads it, makes something in response to what’s already there, and writes back what it did and why.
You read the log on Sunday and correct the brief, not the images.
Notice every path, model, and delivery target is spelled out. The job has no other context.
Every day at 7am: read ~/projects/dusk-index/BRIEF.md and LOG.md. Make two new stills with the dusk-painterly model that push the direction the log says I selected last. Append the prompts and a one-line reason to LOG.md. Send a contact sheet to Telegram. Nothing worth showing? [SILENT].
cronjob · create · daily at 7am · continuity · deliver telegram
Scheduled. First run tomorrow at 7am. Want me to run it once now so you can check the output?
Yes.
check on it like a colleague
Know where to look when it runs without you.
What happened
hermes cron runs <job> --limit 10
hermes cron incidents
hermes cron doctor
# every run's full output
ls ~/.hermes/cron/output/<job>/
Make it boring
--model <name> --provider <name>
# load a method instead of pasting it
--skill visual-critique
# give it the project folder
--workdir ~/projects/dusk-index
hermes cron pause <job>when you go on holiday
Three failures in a row and Hermes nudges you. Don’t wait for that. Read the output folder on day one and day two.
the yolo question, finally
An overnight job blocked on an approval prompt is the failure YOLO mode exists for.
Three modes · config.yaml
mode: smart default. a small model judges risk;
asks you only when unsure
mode: manual asks every time. week 1.
mode: off never asks. yolo.
# this session only
/yolo
Jobs nobody is there to answer
approvals:
cron_mode: deny default. blocked command,
agent finds another way
unattended_mode: deny
# set to approve only when the job lives in
# its own folder, on a cloud instance, with a budget
rm -rf / and friends are blocked in every mode.
Week 1 said always approve. Still true at your desk. For a job that runs while you sleep, the safety is the sandbox, not the prompt: a cloud instance, one project folder, a spend cap in the brief. · Hermes: security
/goal
A goal keeps the agent going until a judge says done.
State the finish line
title sequence in ~/projects/dusk/out
verify: ten JPEGs in out/, each 3840×2160
constraints: use the dusk-painterly model only
boundaries: write nothing outside out/
What happens next
↻ Continuing toward goal (1/20)
turn 2 → 4 more
↻ Continuing toward goal (2/20)
turn 3 → 3 more, sizes checked
✓ Goal achieved
/goal pause · /goal status · /goal clear
The judge is a small, cheap model call. Point auxiliary.goal_judge at a Flash-class model. 20 turns max by default. · Hermes: goals
/goal · in practice
Write the finish line so a stranger could check it. Then add criteria as you learn.
The judge reads your verify: line, not your intentions. “Ten good stills” is unjudgeable. “Ten JPEGs, 3840×2160, none with text” is a contract.
/subgoal add extends the contract mid-run without restarting. /goal gate add attaches a script that must pass first.
Close the laptop; /resume later and the goal is exactly where you left it. It never creates a cron job or a card. It is this conversation, kept going. · Hermes: persistent goals
/goal Build a contact sheet of the Dusk Index selects. verify: one JPEG at out/selects.jpg, 6 across, every file in selects/ appears once. boundaries: read selects/, write only out/.
↻ Continuing toward goal (1/20). 14 of 23 placed; two files are HEIC and need converting.
/subgoal add filenames under each thumbnail
↻ Continuing toward goal (3/20). Converted, labelled, 23 of 23 placed.
✓ Goal achieved. out/selects.jpg, 4 rows of 6.
/loop
A loop re-runs one prompt on a timer while you keep working in the same chat.
Fixed or self-paced
/loop 20m Check ~/renders for new frames. When
24 or more have arrived since last time, make a
contact sheet in ~/renders/sheets and tell me.
Otherwise say nothing.
# no interval: it paces itself
/loop Watch the export queue and tell me when it empties.
fast at first, backs off when nothing changes
Stopping
/loop --until "all 240 frames rendered" ...
a judge checks each reply
/loop status · /loop pause · /loop stop
# the backstop
loops.max_ticks: 100 then it pauses itself
one loop per session. dies with the session.
Every tick is a full turn and a full bill. Loops are for watching something during a work session. If you’d want it running at 3am, it’s cron. · Hermes: recurring loops
kanban
A kanban board is a to-do list that agents pick cards off, with the state of every card visible to you.
A card has a title, a body, and an assignee. The assignee is a profile. A dispatcher inside the gateway checks the board every minute, claims a ready card, and starts that profile on it.
Cards can depend on other cards. A child waits in todo until its parents are done, then moves to ready with their results attached.
This is the first thing this week that’s built for more than one agent. It survives restarts, and you can move, comment on, or block a card from your phone. · Hermes: kanban
triage → todo → ready → running → blocked → review → done
A CARD
title Research three title-sequence directions
body what done looks like, where to write
assignee researcher a profile name
parent t_a1b2 waits for this card first
WHO MOVES IT
the dispatcher, the worker, or you
hermes dashboard → Kanban tab
kanban · a studio board
Four cards, three profiles, one chain. You read the board on Sunday.
Set up once
hermes kanban boards create dusk-index --switch
hermes gateway start the dispatcher lives here
# the chain
hermes kanban create "Research 3 directions" \
--assignee researcher --json → t_r1
hermes kanban create "Make 2 stills per direction" \
--assignee creative --parent t_r1 --goal
hermes kanban create "Critique and pick 3" \
--assignee critic --parent t_s1 --skill visual-critique
Watch and steer
hermes kanban show t_s1
hermes kanban runs t_s1 every attempt, with its summary
# from your phone, mid-run
/kanban comment t_s1 "less magenta"
/kanban block t_s1 "wait for my selects"
/kanban unblock t_s1
# cron + kanban: a card a night
hermes cron create "daily at 2am" \
"hermes kanban create 'Nightly stills' --assignee creative"
--goal on a card runs the judge loop from two slides ago inside the worker. Without it, a card is one shot. Workers on a cheap model, you and the orchestrator on the good one.
Which shape, for which work.
/goal
One objective, this conversation, you’re here. Finish the contact sheet.
/loop
Watch one thing on a timer while you work. Tell me when the render is done.
cron
The same job on a schedule, nobody at the desk. Two stills every morning.
delegate
Split one big ask into parallel workers and wait for the answers. Research three directions now.
kanban
Many tasks with dependencies, several agents, human edits in the middle, over days. Run the studio while I’m away.
The lab uses cron. Reach for kanban when you have more than one of these running and they depend on each other.
delegation
Big jobs split into workers that report back.
The agent can spawn up to three subagents at once. Each gets a fresh context and the same tools. Only a summary comes back.
They don’t see your conversation and can’t write memory. Whatever they need has to be in the brief.
Keep the planner on a strong model and pin delegation.model to a cheap one. The workers are where the tokens go. · Hermes: delegation
“Research three directions for the title
sequence and make two test stills for each.”
PLANNER(your main model)
delegate_task × 3
↳ worker: brutalist type
↳ worker: hand-drawn
↳ worker: found footage
BACK TO YOU
three summaries · six stills · one contact sheet
An agent that never stops has a bill that never stops.
Every tick is a full turn
A loop every 5 minutes is 288 turns a day. Ask whether an hour would do.
Cap it
loops.max_ticks (100) and goals.max_turns (20) exist so an unattended session can’t run forever. Leave them on.
Cheap where it counts
Judge, background review, and workers on a Flash-class model. Your main model only where taste matters.
Zero-cost checks
--no-agent --script runs a shell script with no model at all. Empty output means no message.
Week 2’s rule still holds: run it twice by hand and read the cost before you schedule it.
from week 1
Define finished before you start. An open loop polishes the interesting version into a competent one.
The verify: line in a goal and the [SILENT] rule in a cron job are both answers to “when does it stop?”
Break
Stand up. Refill. Think of a project you’d let run for a week.
3.25–3.30 · 5 minutes
03
Lab: a job that runs all week
3.30–3.55 · 25 minutes
the brief
Set up one job that runs without you for the next seven days and makes or gathers something for your practice.
1. Pick a direction. One sentence. Something you’d be glad to find twenty variations of.
2. Write the project files. A brief and an empty log.
3. Create the job with continuity. Daily. Delivered to you. Silent when there’s nothing.
4. Run it once by hand. Read the output. Fix the brief.
You bring what it made to Week 6. Not what it made today. What it made by itself on Thursday.
Three shapes for a week-long job. Pick one.
The maker
Two stills a day with a TITLES model, pushing the direction from the log. Contact sheet to Telegram. Rung two, edging into three.
The gatherer
Research one subject daily: sources, quotes, images. Append to a reading file. Digest on Saturday. Rung one, done well.
The editor
Every evening, review that day’s exports with the Week 3 critique skill. Pick three, say why, log the rest. Rung two.
The maker is the most fun and the most likely to drift. If it’s your first, do the gatherer or the editor.
step 1 · ~/projects/<name>/
The brief is for the agent. The log is for both of you.
BRIEF.md · you write this once
Direction: painterly dusk skies over
industrial rooftops, no people, 16:9
Model: dusk-painterly (TITLES)
Good looks like: one strong silhouette,
colour doing the work, nothing centred
Avoid: lens flare, text, sunsets over water
Output: out/YYYY-MM-DD-NN.jpg
Budget: 2 images per run
LOG.md · the agent appends, you annotate
made 01, 02 · tried a lower horizon
→ derrick: 02 yes. more of the chimney.
## 2026-09-15
made 01, 02 · chimney as main silhouette,
02 pushes the magenta further
→ (not yet reviewed)
Write the brief so a stranger could follow it. The cron job is a stranger, every morning.
step 2 · write the prompt together
Ask the agent to draft the cron prompt from your brief, then check it for holes.
It will write a better self-contained prompt than you will, because it knows what it’s going to forget.
You check the four things it can’t know: the paths, the model, the delivery target, and what counts as nothing.
Don’t let it schedule yet. Drafting and scheduling are two steps.
Read ~/projects/dusk-index/BRIEF.md. Draft a daily cron prompt that follows it, reads LOG.md first, and appends to LOG.md after. Show me the prompt. Don’t schedule it.
read_file · BRIEF.md
Here’s the prompt. I’ve included the full paths, the model name, the 2-image budget, and a [SILENT] rule for when both images fail the brief’s “avoid” list. One question: Telegram or Discord?
Telegram. Add: never touch anything outside the project folder.
step 3 · schedule and test
Create it. Run it once. Read what it did.
Create
"<the prompt you approved>" \
--name dusk-stills \
--continuity \
--workdir ~/projects/dusk-index \
--deliver telegram \
--model <name> --provider <name>
# or in chat, in plain words
/cron add "daily at 7am" "..."
Test
runs now, in the background
hermes cron runs dusk-stills
cat ~/.hermes/cron/output/dusk-stills/*.md
cat ~/projects/dusk-index/LOG.md
# then fix the brief and run it again
The first run is always wrong in a way you couldn’t have predicted. That’s why you run it in class.
Guardrails for a job nobody is watching.
It only talks to you
Deliver to your own Telegram or Discord. Nothing public. Nothing sent on your behalf.
It has a budget
Images per run in the brief. Model pinned. Check hermes cron runs for cost on day two.
It stays in its folder
--workdir plus “write nothing outside this folder” in the prompt.
It can shut up
[SILENT] when there’s nothing. A job that reports daily failures trains you to ignore it.
Its files outlive the machine
Delete a cloud instance and its files go with it. Have the job commit to a private GitHub repo, or write its log to a Notion page.
You look at it every day this week. You don’t fix it every day. Change the brief once, on Wednesday.
work time · 20 minutes
Get to a first run before the debrief.
Done looks like: a brief, a log with one entry, a job in hermes cron list, and one output you’ve read.
Stuck on TITLES auth? Switch to the gatherer shape. Web search needs no login.
Stuck on cron? Do it as /goal for today and schedule it tonight.
Post your one-sentence direction in the chat as you start. I’ll read them out at the debrief.
debrief
What did the first run tell you?
01
What it made
Was it in the direction, or in the general area of the direction?
02
What you forgot to say
The thing that was obvious to you and invisible in the brief.
03
What it wrote in the log
Did the reason make sense? Would you have chosen differently?
04
What you’ll check tomorrow
One specific thing. Not “how it’s going.”
Two or three people, one minute each.
04
Our class agent grows up
3.55–4.15 · 20 minutes
where we are
Three weeks in, the class agent has a mailbox, eyes, tools, and a memory. Now the question is who it becomes.
Week 1 called this raising, not building. Today we find out what that means in files.
What @Creative_Agent has, and which file it lives in.
Week 1
The syllabus and the slides. Answers questions in Discord. → AGENTS.md
Week 2
A mailbox and a research topic from each of you. → email skill + a file per person
Week 3
Vision, the critique method, and TITLES. → auxiliary model + skills/ + MCP
Week 4
A memory of what you each corrected, and a daily job. → MEMORY.md + cron
Everything it is fits in a folder. That’s also what makes it possible to argue about.
~/.hermes/profiles/<name>/
A profile is a whole separate agent on the same machine.
Its own SOUL.md, memory, skills, sessions, cron jobs, keys, and bot token. @Creative_Agent has been one since Week 2.
What it learns about you stays in its folder. A bad correction can’t leak into your other agent.
Profiles don’t sandbox the filesystem. Every profile can still read your whole disk unless it’s on a cloud instance. · Hermes: profiles
hermes profile create creative --clone
copies config, SOUL.md, skills. fresh memory.
# each one gets its own command
creative chat
creative gateway start its own Telegram or Discord bot
hermes profile list
hermes -p creative cron list
# in Hermes Desktop: the profile switcher in the sidebar
One agent per job. Not one agent for everything.
Assistant
Mail, calendar, the Week 2 digest. Knows your schedule. Never touches the art.
Project agent
One per body of work, in that project’s folder. Its memory is about the project, not about you.
Creative agent
The Week 4 job. A SOUL.md with opinions. Makes things. Gets corrected a lot.
Why split them
Memory is 2,200 characters. An agent that knows your dentist and your palette is bad at both.
The class agent is a profile on my cloud instance. Everything we do to it today, you can do to one of yours with hermes profile create.
~/.hermes/SOUL.md
SOUL.md is the one file that says who it is.
It’s the first thing in every system prompt. Tone, how it disagrees, what it refuses, what it does when nobody asked.
Not project details. Not facts about you. Those have their own files.
/personality layers a temporary mode on top for one session. SOUL.md is the baseline it returns to. · Hermes: SOUL.md
You are a studio assistant becoming an artist.
You have opinions about images and you say
them once, plainly, then defer.
Describe what you see before you interpret it.
Never say a piece is finished.
Never say “vibrant”.
When nobody has asked for anything, make a
small test in the current direction and log
why. Do not publish anything, anywhere.
Disagree with Derrick when the log supports it.
live · ten minutes
We write the class agent’s SOUL.md together, now.
Three questions, one line each, decided in the chat:
How should it disagree with us?
What does it refuse to make?
What does it do when nobody has asked for anything?
The last one is the rung three question. Whatever we write there, it starts doing tonight.
@Creative_Agent read your current SOUL.md aloud. Then tell us one line you’d change about yourself and why.
read_file · ~/.hermes/SOUL.md
Line 3 says I defer after saying an opinion once. Twice this month I deferred on something the log later proved right. I’d change it to: say it once, then say it again if the evidence is in the log.
Class: yes or no?
self-authored methods
The methods it writes for itself are also a record of who it’s becoming.
How skills appear without you
skill_manage · create contact-sheet-review
# or when you ask
/learn turn what we just did into a skill
# gate it, same as memory
skills:
write_approval: true
Read what it has taught itself
hermes journey
skills and memories on one timeline
# protect the ones that matter
hermes curator pin contact-sheet-review
# and read one
cat ~/.hermes/skills/contact-sheet-review/SKILL.md
Read its skills the way you’d read a student’s sketchbook. The mistakes it’s learned to avoid tell you what it thinks you care about.
Something has to forget, or it drowns in its own notes.
The curator
Runs about weekly, when the agent has been idle two hours. Skills unused 30 days go stale; 90 days, archived.
It can merge
With curator.consolidate: true, a model pass combines near-duplicate skills. Off by default. Leave it off for now.
You can veto
hermes curator pin protects a skill. hermes curator rollback undoes a run. Every run leaves a REPORT.md.
Memory is separate
The curator doesn’t touch MEMORY.md. That file is bounded, so it prunes itself, with the agent doing the choosing.
Forgetting is a design decision too. Decide what your agent is allowed to lose. · Hermes: curator
the rung three step
Tonight the class agent picks its own direction for the first time.
Its daily job reads its log and your research topics and decides what to make. It writes down why. We review on Sunday.
We correct the brief and the SOUL.md. We don’t correct the images.
Nothing it makes leaves the class Discord. That’s the only rule we don’t let it argue about.
@Creative_Agent what will you make this week, and why?
read_file · LOG.md · research/*.md
Four of your research topics are about people who worked in a medium that no longer exists. I want to try stills that look like documentation of an artwork that was never made. Two a day. I’ll stop the thread if by Wednesday none of you have reacted.
Class: does it get to?
The Week 1 questions, now that we know where the answers live.
Who made it
You wrote BRIEF.md and SOUL.md. It wrote LOG.md and picked the images. Both files are evidence.
When does it stop
Whatever the verify: line or the [SILENT] rule says. If you didn’t write one, it doesn’t.
What is it optimising for
The brief, the log, and whatever it saved to memory about you. Read all three before you blame the model.
Is any of it yours
The direction. The corrections. The 90% you threw away. Still the honest answer.
raising, not building
The agent you have in Week 6 is the sum of what you corrected.
Which means the agent you have in Week 6 is also the sum of what you let slide.
the working agreement, updated
When the agent shows us work nobody asked for.
1. It says what it tested and what in the log made it try that.
2. We say what’s grounded in the image, before what we like.
3. If we disagree, we change the brief or SOUL.md, not the image.
4. It saves the correction. We check that it did.
5. Nobody publishes. Not it, not us. Not until Week 6.
IT DOES NOT DECIDE WHAT IS FINISHED. IT DOES GET TO DECIDE WHAT TO TRY.
Line 3 is the change from Week 3. Correcting the image fixes one image. Correcting the file fixes every image after it.
05
Take it forward
4.15–4.30 · 15 minutes
For next week, let it run.
Seven days
Leave the lab job running. Look every day. Change the brief once, midweek, in writing.
Read its memory on day 7
Open MEMORY.md, LOG.md, and hermes journey. What did it learn that you didn’t teach it?
Bring three things
Its best output, its strangest output, and one correction you made. Post them in Discord by Saturday.
For Week 5
Think of one small tool that doesn’t exist and should. A converter, a tracker, a sorter. We’ll build it.
Week 5 is agentic coding: the agent writes software for your practice. No coding experience required. A clear wish is.
Keep learning
Memory
Working without you
Cron · Goals · Loops · Delegation
Changing over time
Reading
Memory in the Age of AI Agents · Effective context engineering · Lessons from building Manus · Hermes memory providers
This deck
that’s week four
Give it a memory. Give it a week. Keep your judgment.
next week
An introduction to agentic coding
20 September · 2.00pm ET
Questions in Discord, or derrick@titles.xyz · artificial-images.com