The first bookmark workflow gets saved X posts into Linear.
That is useful, but it is not the whole system. A raw Linear Triage item is still another thing you have to process. The next step is the part I actually want from an agent: read the raw captures, decide what kind of work they represent, and leave me with a shaped Linear task instead of a vague saved post.
This guide wires that second step.
The pattern is:
Everything still lands in Linear. Shape Up is not a separate database. It is the thinking layer that helps decide whether a bookmark should become a blog post, a small experiment, an implementation task, or a research note.
Follow the Always-On Agents course path
Follow the complete public course path, install the skills as you go, and use DevelopJoy when you want the workflow wired into your actual VPS.
Where this fits in the series
Do these first:
- Codex on a VPS: Set Up an Always-On AI Development Box
- Use Codex to Prepare a VPS for Hermes
- Install Hermes/OpenClaw on the VPS
- Connect Hermes to Discord
- How to Use the X API to Turn Bookmarks into Linear Inbox Tasks
The capture article gets source material into Linear. The Discord lesson gives Hermes a review room. This article teaches the agent what to do with captured items after they are visible.
What we are building
We are building a deterministic shell around an agent decision.
The deterministic parts:
- Fetch captured bookmark issues from Linear.
- Generate a strict review prompt.
- Validate the agent's
decisions.json. - Apply decisions back to Linear.
- Store processed issue IDs locally.
The agent part:
- Read candidate issues.
- Score them.
- Choose a work type.
- Use Shape Up to explain the problem, appetite, pitch, rabbit holes, no-gos, and next action.
That split matters. The script handles IO. Hermes, Codex, or another runner handles judgment.
Install the triage skill
Install the public skill files:
On the VPS path from the earlier guide, I would keep it here:
The install path matters less than consistency. Put state, logs, skills, and scripts somewhere predictable so Hermes can run the same heartbeat tomorrow.
Want this wired into your actual VPS?
The full guide is public. DevelopJoy can pair with you to install the skills, connect Linear, set up the heartbeat, and adapt the Shape Up prompts to how your team handles tasks.
Build it with us
Pair-programming lab
$100/moHave us build it
Done-for-you focus sprint
Starts at $500/moConfigure Linear state
Use the same Linear team that receives the bookmark captures:
The state file stores processed Linear issue IDs. Keep it on persistent disk. If you delete it, the agent can review old captures again.
Fetch candidates
From the installed skill folder:
The script looks for Linear issues whose description includes:
That source marker is the contract between the capture skill and the triage skill. The capture script creates raw issues. The triage script only processes those raw issues.
Generate the review prompt
Create a prompt for Hermes, Codex, or another runner:
The generated prompt tells the agent to return only valid JSON. It also defines the allowed work types:
| Work type | Use it when |
|---|---|
blog_post | The bookmark is useful as a teaching artifact, tutorial, comparison, or public explanation. |
small_experiment | The bookmark points at something worth trying before committing to a feature or article. |
implementation_task | The bookmark clearly maps to code, ops, product, or workflow work. |
research_note | The bookmark needs more validation before it becomes implementation or content. |
The key rule is simple: everything remains a Linear task. Shape Up decides how the task should be handled.
Ask Hermes to write decisions
Use the review prompt with your runner.
For a manual Codex pass:
For Hermes/OpenClaw, point the agent at the same prompt and require the same output file:
That last line matters. The agent should not be both the judge and the IO layer. The script validates and applies decisions after you inspect or dry-run them.
Decision JSON shape
The agent writes:
Allowed actions:
convert: turn the capture into an active task.question: keep it as a task, but ask a clarifying question first.park: mark it reviewed and leave it as a parked capture.
Dry-run the apply step
Before writing to Linear:
This validates the decision schema and prints the planned operations. It does not call Linear and does not update local processed state.
If the dry run fails, fix the JSON or regenerate it. Do not loosen validation just because the agent returned sloppy output.
Apply decisions to Linear
When the dry run looks right:
For convert and question, the script can update the issue title and description. It always adds an audit comment with:
- action
- work type
- score
- explanation
V1 does not change Linear status, labels, assignee, priority, or team. That is intentional. The first working version should explain and shape the work before it starts moving tasks around your project.
Run it as a heartbeat
Once manual fetch, prompt, dry-run, and apply all work, put the loop behind a small heartbeat.
One simple shape:
Run that manually first. Then use cron or systemd.
For a daily cron:
For a long-running OpenClaw/Hermes service, use the platform's service controls instead of leaving a terminal open. OpenClaw documents openclaw setup for workspace initialization, openclaw daemon as the service control surface, openclaw logs for runtime logs, and openclaw security audit for security checks.
What good output looks like
A useful converted task should answer:
- What is the source?
- Why does it matter?
- What kind of work is this?
- What is the appetite?
- What should happen next?
- What should we avoid?
A weak task usually fails one of those. That is why question and park exist. The agent should not force every bookmark into active work.
Troubleshooting
Fetch returns no candidates.
Confirm the capture skill has created Linear issues and that the descriptions include Source: x-bookmark-capture-sync.
The agent returns prose instead of JSON.
Regenerate the prompt and tell the agent to return only valid JSON. The apply script should stay strict.
Dry run fails on shapeUp.
Every decision needs problem, appetite, pitch, rabbitHoles, noGos, and nextAction.
The same issue gets processed again.
Check LINEAR_TRIAGE_STATE_PATH. The state file must live on persistent disk and be reused by cron/systemd.
The output is too aggressive.
Lower the appetite in the prompt, prefer question over convert, and keep the daily limit small until the decisions feel trustworthy.
Why this is the monetizable part
The scripts are free because the scripts are not the hard part.
The hard part is making the whole system behave correctly in your environment:
- X API app setup.
- Linear team and Triage setup.
- VPS state and logs.
- Hermes/OpenClaw service setup.
- Prompt tuning for your judgment.
- Recovery when a token expires or the agent writes bad JSON.
That is where DevelopJoy should help. The public guide lets a capable builder walk through the system. The paid offer is getting it installed, adapted, and maintained without losing a week to glue work.