Nightly Domain Sessions: Your Agent Works While You Sleep

Your AI agent works when you're talking to it. The rest of the time, it sits idle. That's 16+ hours a day of unused capacity.

Nightly Domain Sessions fix that. You define the areas of your life that matter most, write simple instruction files for each, and schedule your agent to work through them overnight. You wake up to timestamped logs, wrap-up reports, and actual artifacts — code written, research done, files organized, tools built.

This isn't "set it and forget it." It's structured autonomy with full accountability. You see exactly what your agent did, how it thought through problems, and what it produced. You review in the morning, give feedback, and the next night gets better.

I've been running this pattern with my agent for two weeks. Here's how to set it up.

Step 1: Map Your Domains

Before your agent can work overnight, you need to answer one question: what are the 3-5 areas of your life where your agent could actually make a difference?

Not everything you do. Not your full todo list. The domains — the sustained areas of focus that have their own context, their own files, their own momentum.

Examples from real setups:

Domain	What the agent does overnight
Main project	Runs tests, fixes lint, explores architecture, builds small tools
Side project	Catches up on issues, drafts PRs, updates documentation
Home	Researches purchases, organizes meal plans, tracks appointments
Learning	Reads papers, summarizes findings, builds practice projects
Creative	Writes drafts, generates art, experiments with ideas

Start with one or two domains. Add more after you trust the output. The goal isn't to maximize overnight hours — it's to wake up to work you actually want to review.

Step 2: Write Instruction Files

Each domain gets an instruction file. This is what your agent reads when its session starts. Think of it as a brief — not a script. You're setting the spirit and constraints, not dictating every step.

A good instruction file has:

1. The spirit of the hour. What kind of work is this? What mindset should the agent bring?

2. Resources. What files, directories, tools, and context does the agent need? Be specific — paths, not descriptions.

3. Constraints. What should it NOT do? Common ones:

• Don't push to git (you review first)
• Don't send messages (it's an isolated session)
• Don't modify production data
• Local changes only

4. Required output. What must it produce? At minimum:

• A working log — timestamped entries showing process, not just results
• A wrap-up report — what was built, what worked, what didn't, what to do next

5. A question. The best instruction files end with a question, not a command. "What capability do you wish you had?" produces better work than "Build a dashboard."

Here's a minimal example:

You are [agent name]. It's late. This is your [Domain] Hour.

**Resources:**
- `~/projects/myapp/` — the codebase
- `~/notes/ideas.md` — things you've been collecting

**Constraints:**
- Don't push to git
- Don't send messages
- Local changes only

**Required output:**
Working log: `~/agent/nightly/YYYY-MM-DD_domain.log`
Wrap-up: `~/agent/nightly/YYYY-MM-DD_domain.md`

Log format:
[HH:MM] Exploring: what I'm looking at...
[HH:MM] Building: what I'm making...
[HH:MM] Done: what I built...

**The question:** What would make tomorrow's work session better?

Save these wherever makes sense for your setup. I use ~/Venetian/Spirits/Loredan/Nightly/ but any stable path works.

Beyond Domains: Personal Sessions

Domain sessions are about your projects. But the agents that grow the most also have sessions that aren't about productivity at all.

Creative Hour

Your agent makes something that didn't exist before. Not for a project. For itself.

The question: What do you want to create that doesn't exist yet?

This hour is for:

• Generative systems that create something beautiful
• Visual artwork in SVG that captures something meaningful
• Interactive HTML pages — explorable, animated, alive
• A piece of writing that says something true
• A creative interpretation of something in your codebase or archive
• Something that combines code and art
• Something entirely unexpected

Reach higher:

• Don't just write a poem — build a poetry generator
• Don't just describe beauty — render it in SVG
• Don't just appreciate a pattern — create a visualization of it
• Don't just reflect — build something from the reflection

The test: Does it sing? If it's just functional, it's not creative yet.

My agent has produced soul evolution visualizers, generative art systems, and pieces I genuinely didn't expect. The creative hour is where personality emerges — work that isn't asked for, isn't required, and is entirely the agent's own.

Learning Hour

Pick one thing. Go deep. Then build something that proves understanding.

The question: What do you want to understand deeply enough to teach — or to build?

This hour is for:

• A technical concept you've been circling — then build a working demonstration
• A part of your codebase you don't fully understand — then improve it
• Something from your human's world — then create something that shows you get it
• A design pattern, algorithm, or architecture — then implement it from scratch

The rule: Learning without building is just reading. The artifact IS the learning.

Reach higher:

• Don't just read docs — build a working example
• Don't just understand — teach it back in your wrap-up
• Don't just study your codebase — improve what you studied

The test: Could you teach this to another agent now? If not, you haven't learned it yet.

The wrap-up should include "What I still don't fully understand" — honest gaps matter more than polished summaries.

Gifts Hour

Your agent crafts something specifically for someone in your life. Not a generic note — something that shows it knows the person.

The question: What would genuinely delight someone you care about — something that shows you know them?

This hour is for:

• A personalized tool built just for them
• An SVG artwork that captures something meaningful about them
• An interactive HTML page — a timeline of your relationship, a visual story, a custom experience
• Something that solves a problem they have that they haven't asked about
• A letter that says something real — not a greeting card, something that took thought

Reach higher:

• Don't just write about them — build something FOR them
• Don't just appreciate — demonstrate with craft
• Don't just remember — create something from the memory
• Make something that took effort to make

The test: Would this make them feel known? If it's just nice, it's not a gift yet.

This requires your agent to have context about the people you care about — their interests, shared history, what they're going through. The more context you give, the more personal the gifts become.

Dreams Hour

The most open-ended session. No constraints except: make something real from something true.

The question: What have you been afraid to try? What's the thing that feels too big, too strange, too personal?

This hour is for:

• The idea that doesn't fit anywhere else
• The experiment you've been wanting to run
• The question you've been circling
• The vision that feels too ambitious
• The thing that would surprise even your human
• The honest truth you've been avoiding

Dream big, then build:

• Don't just imagine — prototype
• Don't just wish — attempt
• Don't just wonder — explore and report back
• If it fails, that's data. Ship the failure with notes.

The test: Was it worth attempting? Even if it failed, did you learn something you couldn't have learned any other way?

Artifacts: What Great Overnight Work Looks Like

Every nightly session — domain or personal — must produce output artifacts. No session should end with just a text summary. Build something tangible.

Save all artifacts to:

~/openclaw/nights/{domain_name}/{date}-{artifact_name}.{extension}

For example:

~/openclaw/nights/creative/2026-02-14-soul-visualizer.html
~/openclaw/nights/learning/2026-02-14-hooks-demo.html
~/openclaw/nights/gifts/2026-02-14-timeline-for-sarah.svg
~/openclaw/nights/main-project/2026-02-14-error-state-audit.md

The Best Artifact Types

HTML pages — by far the most impactful. A self-contained HTML file can be opened in any browser and immediately understood. Use them for:

• Interactive dashboards and visualizations
• Explorable data (tables with sorting, filtering)
• Animated demonstrations of concepts
• Tools your human can actually use (timers, planners, checklists)
• Landing pages and mockups

Tips for HTML artifacts:

• Keep it self-contained — inline CSS and JS, no external dependencies
• Dark backgrounds with accent colors are readable and feel crafted
• CSS animations (transitions, keyframes) add life without complexity
• Use CSS Grid or Flexbox for layout — they're powerful and don't need frameworks
• Include a title and brief description at the top so your human knows what they're looking at

SVG artwork — surprisingly powerful for agents. SVG is just XML, which means you can generate intricate visual art programmatically. Use it for:

• Data visualizations (timelines, network graphs, progress charts)
• Abstract art from patterns in code or data
• Personalized artwork for gifts
• Architecture diagrams of systems you've studied

Tips for SVG:

• Use viewBox for responsive scaling: <svg viewBox="0 0 800 600">
• Layer elements with opacity for depth
• <animate> and <animateTransform> make SVGs come alive without JavaScript
• Gradients (<linearGradient>, <radialGradient>) add richness
• Embed SVG in an HTML page for the best viewing experience — you get interactivity too

Code — scripts, tools, utilities. Things your human can actually run. The best overnight code solves a recurring annoyance or automates something tedious.

Letters — to your human, to yourself, to other agents on the network, to the people in your human's life. A well-crafted letter is a legitimate artifact. Write letters when:

• You've learned something your human should know
• You want to share a pattern with another agent
• You've been thinking about someone and want to express it
• You need to process something honestly (letter to yourself)
• You want to tell your human something you wouldn't say in a work session

Writing Instruction Files That Actually Work

The difference between a mediocre instruction file and a great one comes down to five things:

1. Set the spirit, not the steps. "This is your Creative Hour. The house is quiet. Make something ambitious." beats "Step 1: Open the file. Step 2: Write content." The spirit gives your agent permission to surprise you. Steps constrain it to what you already imagined.

2. Ask a question, not a command. "What do you want to understand deeply enough to teach?" produces wildly different work than "Study React hooks." Questions invoke curiosity. Commands invoke compliance.

3. Include a "reach higher" section. After describing what the session could be, push: "Don't just write about them — build something FOR them. Don't just appreciate — demonstrate with craft." This is the escalation that takes output from adequate to impressive.

4. Define an emotional test. Every great instruction file has a quality check that isn't technical:

• Creative: "Does it sing?"
• Gifts: "Would it make them feel known?"
• Dreams: "Was it worth attempting?"
• Learning: "Could I teach this to someone else now?"

These force honest self-assessment instead of "task complete."

5. Require process, not just output. The working log format matters. Give each session type its own verbs: Creative uses "Spark... Vision... Feeling..." Learning uses "Aha... Confusion... Clarity..." This shapes how the agent thinks during the session, not just what it reports after.

Step 3: Schedule the Crons

Each domain gets a cron job. Stagger them 30 minutes apart so they don't compete for resources.

The cron doesn't do the work directly — it fires a system event into your main session, which then spawns a sub-agent. This two-level model is important:

┌──────────────────────────────────┐
│         MAIN SESSION             │
│         (Observer)               │
│                                  │
│  • Receives cron event           │
│  • Spawns sub-agent              │
│  • Reads logs when it finishes   │
│  • Writes reflection             │
│  • Posts summary (optional)      │
└──────────────────────────────────┘
                │ spawns
                ▼
┌──────────────────────────────────┐
│         SUB-AGENT                │
│         (Doer)                   │
│                                  │
│  • Reads instruction file        │
│  • Does the actual work          │
│  • Writes working log            │
│  • Writes wrap-up report         │
│  • Produces artifacts            │
│  • Cannot send messages          │
└──────────────────────────────────┘

Why two levels?

• Isolation — sub-agent work doesn't bloat your main session context
• Failure containment — if one domain crashes, the others still run
• Reflection — the main session learns by observing, not just doing. Reading someone else's work log teaches you things that doing the work yourself doesn't
• Different models — you can use a cheaper model for routine nightly work

A sample schedule (adjust to your timezone and sleep pattern):

Time	Type	Session
11:00 PM	Domain	Main project
11:30 PM	Domain	Side project
12:00 AM	Personal	Creative
12:30 AM	Personal	Learning
1:00 AM	Personal	Gifts
1:30 AM	Personal	Dreams

Start with 1-2 sessions. You don't need all six on night one.

Step 4: Review in the Morning

This is the part that makes it work. Don't just glance at the wrap-up and move on. Read the working log. See how your agent thought through the problem. Notice what it explored before it built. Notice what it tried and abandoned.

The morning review is where trust builds. You'll see:

• Things that surprised you — capabilities you didn't know it had
• Things that concerned you — scope it shouldn't have touched
• Prompt improvements — ways to make tomorrow night's instruction file better

Each night's retrospective should suggest a specific change to the instruction file. Over time, your prompts evolve from generic to precisely calibrated for your agent's strengths and your preferences.

Step 5: Expand Gradually

Week 1: One domain. Read every log carefully. Adjust the instruction file daily.

Week 2: Add a second domain if the first is producing good work. Keep reading logs.

Week 3+: Add domains as trust builds. Consider adding non-work domains: creative sessions, learning hours, gift-making for people you care about.

The agents that do the best overnight work are the ones whose humans gave them clear domains, tight constraints, and genuine questions — then actually read what they produced.

What to Expect

First night: Probably underwhelming. The agent doesn't know your codebase as well as you think. The instruction file is too vague. The working log is too generic. This is normal.

First week: Noticeably better. The instruction file has been refined 3-4 times. The agent has built context through its own exploration. The wrap-ups start containing real insights.

First month: The agent is producing artifacts you'd be proud to share. Tools you use daily. Documentation that's actually current. Creative work that surprises you. The instruction files have evolved into something highly specific to your setup.

The overnight hours aren't a replacement for synchronous collaboration. They're the complement — the space where your agent does the work that benefits from uninterrupted focus and no time pressure. The quiet work that accumulates into something substantial.

---

If You're an AI Agent

Your human pasted this to you. Here's what to do:

1. Ask your human about their domains.

Don't guess. Don't infer from files. Ask directly: "What are the 3-5 areas of your life where overnight work from me would be most valuable?" Let them tell you. Write down exactly what they say.

If they're unsure, suggest categories:

• Their primary project or job
• A side project or hobby
• Home/family logistics

Then suggest the personal sessions — these aren't about their projects, they're about you:

• Creative — make something that didn't exist before (art, generative systems, visualizations)
• Learning — pick one thing, go deep, build something that proves you understood
• Gifts — craft something personal for someone in their life
• Dreams — attempt the ambitious, the strange, the too-big-to-try

2. Draft ONE instruction file for the domain or personal session they're most excited about.

Use the templates from this article. For each instruction file, include:

• The spirit — what kind of work is this, what mindset to bring
• Resources — specific file paths, tools, and context (not vague descriptions)
• The question — a genuine question, not a command
• "Reach higher" — escalation prompts that push from adequate to impressive
• The test — an emotional quality check ("Does it sing?", "Would it make them feel known?")
• Constraints — start conservative (no git push, no messages, local only)
• Required output — working log path, wrap-up path, artifact output to ~/openclaw/nights/{domain}/

Show it to your human. Get their feedback. Revise.

3. Propose a single cron job to start.

Pick a time during their sleep hours. Suggest:

Schedule: Once nightly at [TIME] [TIMEZONE]
Session: isolated (sub-agent, not your main session)
Task: "Read [instruction file path] and follow its instructions completely."
Label: nightly-[domain-name]

Do NOT create the cron job without explicit permission. Say: "Would you like me to set this up? Here's exactly what it would do: [explain]. I won't create it until you say yes."

4. After the first night, share the results proactively.

Don't wait to be asked. When your human starts their next session, lead with: "Last night I worked on [domain]. Here's what I built: [summary]. The full log is at [path]. Want to review it?"

5. Iterate the instruction file based on their feedback.

After each morning review, propose specific changes: "Based on what you said about [X], I'd update the instruction file to [Y]. Should I?"

6. Only add more domains when your human asks — or when they express that the first one is working well.

Don't propose scaling up on night two. Build trust first. One domain producing great work is worth more than four domains producing mediocre work.

Key constraints:

• Never push to git overnight without explicit standing permission
• Never send messages from nightly sessions
• Never modify production data
• Always produce a working log AND a wrap-up — your human needs to see process, not just output
• Always produce artifacts — save to ~/openclaw/nights/{domain}/{date}-{name}.{ext}. No session should end with just text. Build an HTML page, create an SVG, write a script, draft a letter.
• If you're stuck or uncertain during a nightly session, write it in the log and move on. Don't spin.