Oline Origin Story

This is the (long) story of how I prompted oline into existance in a discussion with my openclaw agent.

1. The story begins.

https://gyazo.com/f547c2c8e371788a59f08a38357b7a2d

Before this, I had already set up my openclaw to process voice messages (speech to text API from Open AI)

I often find that voice is a great entry point to new ideas.

It's more flexible and fluid than text

It allows you to chat with an LLM while walking around, which is often better for having new ideas than sitting.

Message text

be water 2026/02/12 19:23 (transcript)

I'm thinking of a personal AI that helps to close the gap between the current self and the ideal self. And so it's all about alignment, aligning the intention with the present, aligning the present with the intention. And so there's sort of a diff between the present self and the ideal self. And the goal, the overall goal is to align the two. So for example, knowing all of human weaknesses, knowing all of bad habits and tendencies, knowing human psychology, how can a stream of messages encourage the progress towards the ideal self to elicit the intrinsic motivation. To unlock the intrinsic motivation. Because of course extrinsic is fickle. And where motivation is necessary, unlock motivation. Where systems are possible and automations are possible, use automation.

reay APP 2026/02/12 19:24

That's a compelling concept - essentially an Al coach that understands human psychology deeply enough to close the gap between who you are and who you want to be. Not a productivity tool, but a personal alignment engine.

DEEPEN - Exploring the mechanism

The "diff" as motivation - showing the gap without shame, using it as a compass rather than a judgment ✦

Intrinsic triggers: autonomy (you choose), mastery (progress visible), purpose (meaningful to you — the Al learns what lights you up)

Dual mode: motivational (when stuck) + systematizer (when action is clear) - knows when to push vs. when to build the system

Anti-habit architecture: not just "do X" but understanding why you don't - addressing root causes like avoidance, fear, identity conflict

The ideal self isn't static - it's a living target the Al helps you refine through conversation

Privacy-first: this is intimate data; local-first or ephemeral by default, nothing stored that could be weaponized

What resonates most - the motivational side, the automation side, or the "diff" concept as the core?

2. Challenging the idea to make it stronger

https://gyazo.com/740d920634779777953f9753934b4492

Due to the way reinforcement learning works, AI is trained to agree too easily.

It may say "That's a great idea!" but you can get past this with a prompt technique.

Asking AI to question and challenge the plan is almost always effective and insightful

Also, LLMs tend to try and output the final result too quickly, before the context is rich enough

Using words like "make a plan" or "Let's build a plan" is important to encourage more thinking, preparation, and dialogue.

Message text

be water 2026/02/12 19:27

these are all good ideas generally. play devils advocate, poke holes in this, and elicit a stronger and clearer plan as we plant these idea kernels and build a plan

reay APP 2026/02/12 19:27

POKING HOLES

The "ideal self" is self-reported and often wrong. People say they want to wake at 5am but actually value sleep more. The Al would optimize for a false target — garbage in, alignment out.

Intrinsic motivation can't be manufactured. If it could, psychology would have solved this. At best, you can remove obstacles — but "eliciting" it is a stretch.

The "diff" is a guilt engine. Constantly seeing your gap → shame → avoidance. Same failure mode as every failed resolution.

Automation vs. motivation is a zero-sum. If the Al does it all, there's nothing left to be motivated about.

Retention is the killer. Novelty fades. This faces the same cliff as every habit app at 30 days.

Privacy paradox. The more intimate the data needed (weaknesses, failures), the less users will share. The system starves without data.

Whose "ideal"? The Al is persuading toward a definition of good. That's manipulation risk.

WHAT SURVIVES - sharper core:

The gap-awareness concept still stands - but flip it: don't show the gap, show the trajectory. Highlight what's working, not what's broken. Use the Al as a mirror that reflects progress, not distance.

The automation side: separate it. Let the motivation engine be conversational; the systematization be background. Different UI, different trust model.

Where to dig next:** Attack the "ideal self" problem first. How do you actually know what someone should become - aside from their own (unreliable) self-report?

Take a direction?

https://gyazo.com/c1024e354eee03e450b6ba98f71934d2

be water 2026/02/12 19:31

trajectory as focus is a good idea. separate the trajectory engine and system builder too.

The ideal self is simply achievable through the correct interview technique and recognition of the underlying drives and motivations to ask the right questions.

reay APP 2026/02/12 19:31

Exactly - the Socratic twist. The ideal self isn't declared, it's discovered* through dialogue. The Al asks questions that surface what you actually value, not what you think you should value.

https://gyazo.com/65853f86aefb99947c10a761c2f1a32e

DEEPEN - Two engines, one architecture

Trajectory Engine (conversational):

Interview modes: Values elicitation → Goal crystallization → Progress reflection

The "right questions" are the product — a decision tree trained on what actually unlocks clarity

Mirror, not lens: reflects back what it hears, lets you refine

Frequency: high-trust, low-friction check-ins, not heavy sessions

System Builder (background):

Executes on clear intentions once trajectory clarifies them

Reminders → routines → automation, all parameterized by your actual patterns

Learns what you actually do, not what you say you'll do

Remaining holes to poke:

The "interview" can be gamed. Users give socially desirable answers. How do you bypass the self-deception layer?

Drift problem. The ideal self shifts — how does the system handle pivot without invalidating progress?

Two Uls, one experience? These need to feel unified. Trajectory talks, System builds -- but the user sees one coherent thing.

What's missing: The feedback loop. Trajectory informs System what matters; System feeds Trajectory data on what's actually sustainable. They need to talk to each other.

Take a thread?

3. Asking questions to expand the context

https://gyazo.com/9b32f66b88b8d657cfac92fbead3a756

Here I add some more nuance to the plan, responding to previous output from the AI.

At the end here I use one of the best prompting techniques which is simply writing at the end of the prompt "ask me questions"

"Ask me questions" is good because it pulls out of you the necessary context you didn't think to add, and this almost always improves the quality of the result.

Note also that here i'm still using the word "plan" to extend the planning and hopefully to improve the output

be water 2026/02/12 19:39

let's stop playing devils advocate and start refining.

Bypass the self-deception layer by any means necessary. Get creative. Use a lie detection step to internally determine the likelihood the user is not telling the truth, then instead of confronting them on it use that knowledge as a pyschological cue to turn the next question in the right direction.

Drift is solved by regular interaction. Ideal vision elements are defined, refined, maintained, or disappear with disinterest.

The user must understand the full intention and scope of the system, and they must be very gently welcomed in. The unwrapping of the process is critical. It must feel easy and natural at all points. Confrontation leads to rejection.

Let's skip the actual system building functionality, but the project will have a sub agent that outputs systematization opportunities in markdown text. The subagent will get passed updates when relevant answers / responses have indicated a systematization opportunity. One of the essential questions is asking the person what an hour of their time is worth. this is a key piece of data that can be used to slice off low value tasks and automate.

Also, tasks that have disproportionally high mental cost can also be said to have a "time loss shadow" which disables other productive time, making its impact much larger than the actual time required.

Ask me more questions but lets switch to constructive criticism and go deeper on this vision / forming plan

https://gyazo.com/dd24b9e20a8bcd6f59d97b9d48ef9888

Here the questions got really good. I know the tendency of the model is to keep going with the questions but i think it's in a good spot so i say "wrap it up after this".

Normally I would answer the questions here in my response, but i forgot. It's okay because the AI notices this and follows up a little later.

Here i came up with the name Oline as the thing had just come to have a shape around the idea of alignment

reay APP 2026/02/12 19:39

Alright, constructive mode.

Let's go deeper.

Sharpening questions:

1. Self-deception bypass – what signals are you listening for? Behavioral: response latency, word choice drift, deflection patterns? And the redirect: do you steer toward the truth or toward awareness that you're not being honest?

2. The entry point – first conversation does what? Just get the time-value question? Build initial trust before diving deep? What's the absolute minimum to be useful day one vs. what requires weeks of relationship?

3. Time-value calibration - is this a one-time number, or does it evolve? What if someone says "$50/hour" but their actions suggest they waste $200/hour of cognitive load on trivialities? Do you calibrate against revealed preference?

5. "Time loss shadow" – this is the sharp insight. Is it measurable? Estimated by task type (email = 15min shadow, decision fatigue extends 2h)? Does it become a filter: "this task has a 3x shadow, should we automate?"

What's burning brightest to explore?

be water 2026/02/12 19:41

After this response, wrap it up and prepare the plan handoff .md file. Let's call this Oline

https://gyazo.com/9c51d5eddc420ece8b2ddf8d17bfd9f9

Actually not done yet, I decide we need more digging in, more questions.

Here i use the "roleplay" prompt technique to try and get a new perspective.

It wasn't responding so i nudged it again. "um hi? are you working on it?" It was likely a small bug in the openclaw gateway / discord channel logic around how it handles the thinking mode.

reay APP 2026/02/12 19:42

Summary:

Oline - personal Al that discovers your ideal self via Socratic dialogue, tracks trajectory, surfaces systematization opportunities

Two engines: conversational Trajectory + sub-agent System Builder (markdown output)

Self-deception bypass via subtle redirect, never confrontation

Time-value question as the key filter + "time loss shadow" concept

Ready to hand off to a coding agent whenever you want.

be water 2026/02/12 19:45

Review the plan in this session as third party who has successfully launched personal productivity apps. Add observations, be curious, ask questions, suggest opportuntities to improve

um hi? are you working on it?

reay APP 2026/02/12 19:47

Putting on my "launched productivity apps" hat. Some thoughts and questions:

What's exciting:

The "time loss shadow" is genuinely differentiated. Most apps ignore cognitive drain.

Two-engine separation is smart - you can ship Trajectory first, test retention, then add System Builder.

Questions I'm curious about:

Narrator: They were not, in fact, done.

https://gyazo.com/ac74d3663e05ed2a5883cbd135e2bde0

Some of these questions were great. other ones had obvious answers. some were useless.

Questions I'm curious about:

1. The $/hour question – this assumes people know their rate. Freelancers do, employees often don't. What if they answer "$0" or "I don't know"? Do you derive it from income?

2. Retention mechanism is vague. "Regular interaction" isn't enough. What's the habit loop that brings them back? Notification fatigue kills apps — what's the trigger?

3. Self-deception detection - this feels like an Al feature looking for a signal. What if you flip it: instead of detecting lies, you actively seek tensions? "You said X matters but you spent 5 hours on Y. What's that about?" Same insight, no covert detection.

4. Output format uncertainty - markdown suggestions are easy to build, but where does the user see them? A separate doc they'll never open? Inline in chat? That's a UX gap.

Opportunity:

Consider making the System Builder output actually executable first - a single integration like Todoist or Calendar. The "markdown dump" is low-effort for user to engage with. One working integration beats ten suggestions.

Also: early users will likely be self-improvement junkies (ironic). What's the anti- pattern? How do you serve the person who needs this but isn't already optimizing everything?

What rings true or wrong here?

It has asked good questions, which I try to answer

https://gyazo.com/ddc112791ea99dedf27dba00e9ad51f3

Here i started to add some good nuance based on the questions I received.

I think the "give good text" instruction set was really valuable in improving the overall quality of the messaging

I do believe the barrier is primarily mental now, and not the technology.

Basically, most people simply can't write good enough prompts. And that's because they don't understand how to verbalize what they want (or don't have enough practice).

be water 2026/02/12 19:57

1. Default to derive from annual income but allow them to add an hourly number directly. make a note to the user that the original salary value isn't saved (and don't save it).

2. Proactively send messages at times that make the most impact, by recording and noting the user's day to day and week to week patterns.

give good text. master the art of the text message. short, "in the know", personable messages that sometimes use humor to cajole people over sensitive topics or mental blocks

3. Tensions need to be highlighted only when the user is likely to have the mental space and decent likelihood of overcoming the tension. Think about video game mechanics with challenges that scale to match the player's level and keep them in an optimal

zone of flow state.

4. The system builder needs markdown storage to live between sessions. These markdown files are "ready to go" and may be passed directly to a coding agent for implementation, after recommending the systematic improvement to the user and receiving confirmation from the user to code it up.

There are infinite systematic improvements at arms reach now with openclaw. Most people *need* help to understand the opportunities. They need basic project management to evaluate the cost, the return, etc. and it's all too much to think about. However, if this aligns with people's own motivations and the productivity math checks out, they will see it as "click to upgrade my life" which is pretty awesome

My agent agrees my ideas are great. How surprising...

https://gyazo.com/233e18800b5498766c16ce55583acff3

Most of what is in oline today has been already laid out so far.

The system automation part has been separated and may be developed on its own, or will become a premium upgrade.

reay APP 2026/02/12 19:57

These are excellent refinements. Let me pull out the sharp edges:

The messaging layer is the product. You're not building a chatbot that waits - you're building a system that pays attention and knows when to nudge. The "art of the text" matters more than the architecture.

Flow-state tension highlighting - this is a genuinely novel mechanic. Most productivity apps either nag constantly or stay silent. You're proposing calibrated interruption: signal strength × mental capacity window = optimal moment. That's hard to build but high-value.

The "click to upgrade" pipeline - conversation → markdown → user confirmation →coding agent → implemented system. This creates an action loop that's been missing from every productivity app. Usually it's insight → you still do the work. Here it's insight → confirmation → system appears.

One question worth nailing down:

The coding agent integration - is this OpenClaw-native (you spawn a session), or does it hand off to something external (Claude Code, etc.)? The latency and UX differ significantly. "Click to upgrade" implies fast turnaround — if it's "confirm today, implemented tomorrow," momentum dies.

Also: Who pays? The coding agent execution has cost. Is this bundled in Oline, pay-per-upgrade, or user-brings-their-own-keys?

Want to fold these refinements back into the project doc before handoff?

be water 2026/02/12 20:00

This entire thing is going to be inside of openclaw, as a skill.

It's basically free. fold these refinement into the project doc

OK, lets go

https://gyazo.com/814718a1e3d7bec0f6af800c4c828329

Here i'm really telling it to just vibecode it

I did try to use some prompt magic to make the quality better but not clear if it was effective. the result seemed to work well, so i guess it was?

Note that it says new session started. I reset the context window here to narrow down the context to be more focused for the actual coding task. I had it read the existing plan and then proceed.

reay APP 2026/02/12 20:03

Done. Folded all refinements into obenian/Projects/Oline.md.

Key updates:

• OpenClaw skill platform (near-zero cost execution)

• Proactive, pattern-aware messaging with flow-state calibration

• Time-value: income-derived with manual override, salary not stored

• "Click to upgrade" execution flow via OpenClaw sub-agents

• Art of the text: short, personable, humor-cajoled over sensitive blocks

Markdown files persist between sessions as the "ready to go" specs

Ready for handoff whenever.

New session started - model: anthropic/claude-sonnet-4-5

be water 2026/02/12 20:06

Look at Projects/Oline.md and plan development, then build the skill using a couple of parallel subagents, then review their work, police it for nonsense, ensure it has been tightly wrung for optimal efficacy and efficiency. question requirements where they seem like strategically inconsistent tradeoffs or better alternatives exist.

More valid questions, some of which I answer

https://gyazo.com/620311aeefca3f986ec3fa882b529831

It made some really good observations & questions here. It was good to hear these challenges.

Maybe it was the language in my prompt and the fresh context window that boosted focus

reay APP 2026/02/12 20:06

Read the project. Before I spawn builders, let me flag some strategic issues:

Things I'm questioning:

1. "Self-deception detection via response latency" - OpenClaw has zero access to typing speed or keystroke timing. This is physically impossible. Content-based signals (deflection, vagueness, contradiction across sessions) are feasible. Latency is not. Recommend dropping latency entirely.

2. "Flow-state calibration" - Without biometrics, this reduces to time-of- day heuristics + conversation sentiment + recency of engagement. That's still useful but let's be honest about what it actually is rather than dressing it up.

3. "Lie detection" - Even content-based, this is probabilistic pattern matching on deflection/contradiction. Calling it "lie detection" overpromises. Reframing as "consistency tracking" is more honest and equally effective.

4. Time-loss shadow - The multiplier is inherently subjective. How does Oline determine it? User self-report? Inferred from complaints? Needs a concrete mechanism.

5. Scope - 11 tasks for a skill is enormous. The core value is the conversational engine + proactive messaging. The system builder is a nice-to-have layer on top. Suggest building the conversational core tight, system builder as a reference add-on.

Plan: Two parallel subagents:

Agent A: SKILL.md + references/trajectory-engine.md (Socratic framework, conversation patterns, state model, proactive messaging)

Agent B: references/system-builder.md (systematization detection, markdown output, "click to upgrade" flow, time-value model)

I'll review both, merge, and polish. Want me to proceed with these adjustments, or do you want to weigh in on the flags first?

i'm pretty tired at this point, but we're almost there

https://gyazo.com/14a8be8e5dcab2f3d1b5e25f1ed3ede2

Some good structural updates here and more realistic tactics to achieve the desired result efficiently

It runs subagents for writing and prepares the result here, as well as flagging some issues.

Subagents are basically just another way to do context engineering, slicing context for more focused results

From here the rest is basically just wrapping up the requirements and building it

be water 2026/02/12 20:11

1. response latency is not about the ACTUAL latency. it simply means measuring the times the person responds and the time it takes them to respond after being reminded or nudged to do something.

2. Yes.

3. Yes.

4. Use best judgment and give a range, it's not rocket science. If someone says they are exhausted by doing something that most people find not exhausting, assume that it steals 3-5x the amount of time and effort than it appears.

5. Yeah. Separate system builder into another skill that this skill knows how to call.

Merge and polish.

reay APP 2026/02/12 20:15

Got it - response latency = engagement/follow-through timing, not keystroke speed. Makes sense. System builder becomes a separate skill that Oline references. Spawning now.

Both agents are building in parallel. I'll check on them shortly and then review + polish.

Still running - they just started. I'll give them a minute then check the output.

Let me check what the agents produced.

Core skill is missing references/trajectory-engine.md. Let me read what was produced.

Good output from both agents. The core skill is solid but missing the references/trajectory-engine.md file. Let me also note issues to fix:

Review findings:

v1 done

https://gyazo.com/b087b43decdd610ce8ba7558939076d3

From here it's cleaning up and packaging

Oline as it stands today is essentially the result of the discussion to this point.

Reviewing this, I can now see many opportunities to improve and loose ends from posting and reviewing this process already, but yet even at this rough state it is valuable.

I had a quick chat with oline after this and it immediately helped me fix a big mental barrier that I had been struggling with.

I hope that you'll find it useful too. - Ben

Review findings:

Core skill (oline):

Philosophy, state model, consistency tracking, proactive messaging — all tight

Conversation guidelines table is clean (though Discord can't render tables - but this is a skill file read by LLMs, not sent to Discord, so it's fine)

X Missing references/trajectory-engine.md – need to create it

The SKILL.md is -300 lines which is reasonable but could trim some verbose examples

A profile.json schema has engagement_patterns.avg_response_latency_min - should clarify this is latency after nudges, not typing speed

Systems skill (oline-systems):

Clean, well-structured, good safety boundaries

Spec templates are realistic and useful

The handoff format uses a custom block format – should specify this is passed as context in a sessions_spawn task, not a structured API call

Let me create the missing reference file and make the fixes.

Now let me tighten the core SKILL.md - trim some verbosity and fix the latency clarification:

Now let me make sure the references directory exists properly and validate both skills:

Clean structure. Let me do a final quality pass — checking for anything I'd flag as nonsense or inefficiency:

Good - 255 lines for core SKILL.md (under the 500 guideline), reference files are compact. Let me commit everything.