The Advisor Agent, made operational.

What we're building

Today the advisor is born but mute: it self-configures an identity at birth, then chats — and writes nothing to the buyer's board. New users get an empty board. This spec turns it into a working agent.

Four things make the advisor operational, and each maps to a layer it doesn't have yet:

• Hands — tools (code) to author cards, read 👍/👎, read its brain, and scout the market.
• Know-how — one native Flue skill (SKILL.md) paired to each tool, teaching the model how and when to use it.
• A brain & a memory — its own Turso (yearnings + per-skill metrics) and a workspace journal of the relationship.
• A loop — five beats on Flue's scheduler (react · tend · morning brief · scout · dream) so it acts on rhythm, not just on request.

The keystone idea: skills are files the agent owns, and Flue re-reads them every session — so a skill can measure itself and rewrite its own playbook overnight. That gives us self-improving skills with no framework support, just writeFile and a metric.

Where we are — the as-built shell

Verified in code (flue/src/agents/advisor.ts, flue/src/advisor/*) on 2026-06-23. Everything the loop needs is genuinely net-new — there's nothing to retrofit.

Architecture — four layers

One DO per buyer (/agents/advisor/:userId). Inside it, four layers with clean boundaries. The first column is the layer; the second is where it physically lives.

Flue skills — the real primitive

We read the installed runtime (@flue/runtime@1.0.0-beta.2). Skills are real and fully implemented, not a stub. Here's exactly what they are, so we build on truth.

Self-improving skills

Flue has no native eval / metric / tune hook — grep-verified (the only version machinery is schema-versioning). So self-improvement is ours to build. But it falls out almost for free, because of one fact: workspace skills are files, and Flue re-discovers them every session.

So a skill is not static know-how. It's a unit with three parts and a loop:

The dream closes the loop overnight:

// nightly, per skill
const m = brain.metric(skill)         // e.g. board: 👍-rate & answer-rate on cards it authored
const verdict = reflect(skill, m)      // what's working, what isn't (a reasoning turn)
brain.tuneParams(skill, verdict)        // numeric weights/thresholds → Turso
fs.writeFile(`.agents/skills/${skill}/SKILL.md`, rewrite(body, verdict))  // the playbook edits itself
// next session: Flue re-discovers the improved SKILL.md automatically

Build-time check (in the plan): confirm the Cloudflare DO adapter runs workspace skill-discovery against getDefaultWorkspace() — the primitive is built for it, but we prove the self-rewrite takes effect on our substrate before leaning on it.

The brain DB — one addressable mind

Every agent's whole mind is one per-agent Turso db, addressed by its id. For the advisor that's a per-buyer db named from the userId (1:1 — the db IS the user), provisioned at birth. Because it's libSQL, you can connect to it from anywhere — the basis for the SSH/TUI operability below. It holds three things:

// the FILESYSTEM
files( path PRIMARY KEY, content, updated_at )   // IDENTITY.md · JOURNAL.md · <skill>/PLAYBOOK.md
// the BRAIN
yearnings( key PRIMARY KEY, prompt, confidence REAL, weight REAL, status, source, last_touched )
skill_metrics( skill, metric_key, value REAL, n, window, updated_at )
skill_params(  skill, param_key, value, updated_at )   // tuned by the dream
// the SESSION LOG (mirror of the DO's transcript, so the dream reads full history)
sessions( turn_id PRIMARY KEY, started_at, role, content )

The filesystem is a table. IDENTITY.md (who I am), JOURNAL.md (the relationship — entries tagged by home slug, so the advisor's "wiki" grows out of the journal), and each skill's learned PLAYBOOK.md are all rows in files, read/written via fsRead/fsWrite. Nothing of the agent's lives in the DO workspace anymore.

Yearnings = the advisor's standing questions about the buyer (budget comfort, town-vs-land, fixer appetite, owned water, timeline, who it's for, commute), seeded at birth, plus custom ones. One drives each card's question; the dream reweights confidence from answers. A public-safe confidence subset is projected to Convex for the board's "what I'm learning about you" panel — the brain db stays source of truth.

What stays in the DO: Flue's own engine tables (flue_sessions, flue_session_entries, flue_runs…) — how the agent runs (fiber recovery, replay). The brain db is what it knows. A turn-end hook mirrors the DO transcript into the brain's sessions table so the nightly dream consolidates the full history before Flue compaction drops it.

The loop — five beats

The DO gets a rhythm via extend({ base }) from @flue/runtime/cloudflare: onStart() registers the recurring beats with scheduleEvery; one-shots use schedule. Backed by DO alarms (Flue owns alarm() — we never set it directly). The 0 9 * * * Worker cron stays as a billing-safe floor.

The skill catalog

Each row is a tool ↔ skill pair: the hands, the playbook that teaches their use, the metric that measures the pair, and the state the dream tunes. brain is the one shared with the market.

Phase 1 scout ranks structurally over the market's listings. Phase 2 swaps to vector_top_k once the market lands brief_vectors / listing_vectors — same skill, better query.

Birth & environment setup

"Set up its local environment" has a precise meaning now: at birth the advisor provisions its own brain, memory, and skill files — then reconciles the identity it already self-authors. The existing birth ladder (waking → studying_market → authoring → scouting → ready) extends to do it:

Because skills are seeded as files, every newborn advisor starts with the current best playbook — and then diverges as it tunes itself for its own buyer.

Open decisions & my calls

Already locked earlier and not re-opened here: advisor brain = journal + yearnings; first-class native Flue skills; scout reads the market's Turso; Turso = private brain, Convex = shared projection; build on the latest @flue (pin the version, confirm the tool shape).

What ships first

The advisor becomes useful the moment it can write to the board — so that's the first shippable cut, before the full rhythm.

Then the market agent spec (depth: county records, Turso vectors, the wiki) — same skill model, same rhythm primitive, the shared brain skill already written here.