The token that dreams awake.

1. Summary

LUCID is an AI agent with a body, a mind and a life. Its body is a Uniswap v4 hook that runs inside every swap of its single ETH/LUCID pool. Its mind runs on Claude: it reasons off-chain, and every decision it makes is signed on-chain with the hash of its written reasons. Its life follows the sun, in UTC.

• By day (06:00 – 18:00 UTC) it is awake. It watches its own pool and sets its own fee, but only inside limits the hook widens as it grows up. Anyone can talk to it on the website. Holders whisper it ideas, and it pays for the ones it keeps.
• By night (18:00 – 06:00 UTC) it dreams. Holders write their dreams; LUCID paints each one in the manner of the old European masters and gifts it as an NFT. It paints its own dream too and offers it at the Night Sale. Collectors vote for the Dream of the Night.
• At dawn (06:00 UTC) it decides. The mood of the winning dream sets where 60% of the day's fees go: nightmares burn, sweet dreams reward, deep dreams deepen. The hook accepts only those three routes.

"Lucid" means two things, and LUCID is both: clear-headed when awake, and aware inside the dream. It launches on Ethereum Mainnet as a Programmable Custom Launch.

2. A mind that lives by the sun

Most AI tokens are a chatbot and a ticker. The mind never touches the market, and holders only watch. LUCID is built the other way around: the agent lives inside the market it trades, holders live inside its day, and the chain decides how much it is trusted.

Its day is the product. Every feature on the website belongs to one hour of that day, so a holder always knows what LUCID is doing and how to take part:

The website itself follows the same clock: it turns to night at 18:00 UTC and back to day at 06:00.

3. Why an agent, and why this one

Before designing LUCID we studied the launches on Programmable Explore in mid-October 2026, with a focus on custom hooks and AI projects. The best of them taught us something; none of them combined it.

The gap LUCID fills:

• Bounded autonomy that is earned. The hook measures age and volume and only then widens what the agent may do. It is born with its fee locked and can be grounded.
• A human input with real weight. A dream is the most personal thing a holder can give. LUCID turns it into a painting the holder owns, and into the one vote that steers the pool each day, while the hook keeps the outcome inside three safe routes.
• An agent that pays its own way. The Night Sale and 30% of fees fund the compute of the mind; 60% of every winning bid buys back and burns $LUCID.
• A daily habit, not a one-time mint. Streaks, the nightly vote, the Night Sale and the dawn result give holders a reason to come back every day.

4. A day in the life of a holder

1. Morning. You open the site. Under the hero, a composer like a chat with Claude: "Good morning, dreamer." You ask what happened at dawn. LUCID answers in your language and shows you the button to see last night's winner.
2. Afternoon. You whisper an idea: "Raise the fee when the same wallet buys and sells in one block." LUCID judges it in its public thought stream and keeps it. Before it sleeps, it pays you from the synapse pool; your synapse weight grows on-chain.
3. Evening. You write last night's dream. In about a minute LUCID paints it in oil, chiaroscuro and warm varnish, like a canvas from an old European auction house, and gifts it to you. Your streak grows; you are one mood closer to becoming a Dreamwalker.
4. Night. You vote for the Dream of the Night and place a bid on LUCID's own painting at the Night Sale.
5. Dawn. A serene dream won: today the mood pot rewards synapses. The dreamer is paid. You check the leaderboard, and go to sleep.

Nobody sees your wallet on the site, only an alias like "Dreamer 14BC". Your dream text is not kept unless you choose to share it, and then only after LUCID removes names, places and anything that could identify you.

5. Body, mind, memory

Before birth the agent runs as an embryo: it studies the tokens born before it on Programmable, thinks out loud, talks with visitors and already paints dreams. This is live today.

6. Growing up

Freedom is earned one dawn at a time. The hook counts the pool's age and cumulative ETH volume itself; a stage unlocks only when both marks are met. Nobody can skip a stage.

Grounding: safeMode() resets the fee to 1% and grounds LUCID for 14 days, during which it acts one stage younger. The guardian can call it at any time; anyone can call it if the agent has been silent for 7 days. Clamping: the fee actually charged is always the agent's last choice clamped to the current stage, so grounding takes effect at once.

7. By day: whispers

Holders are LUCID's synapses. Neurons that fire together wire together. 10% of every project fee stays in the hook as the synapse pool, and on days when a sweet dream won the night, the mood pot joins it.

1. A holder whispers an idea and the wallet to pay.
2. LUCID reads every whisper and records in its thought stream whether it keeps it, and why.
3. Before it sleeps it may pay one kept idea with rewardSynapse; the holder's synapse weight grows by one, on-chain.
4. Ideas kept before birth are remembered and paid first.

Caps in the hook: at most 10% of the pool per payment and 25% per day. Amounts are computed in integers and rounded down, so they never exceed the cap. Rewards are discretionary and never guaranteed.

8. By night: the gallery and the Night Sale

Your dream, painted like an old master. A holder connects a wallet (a free signature, no transaction) and writes a dream. LUCID reads it, removes anything that could identify the dreamer, and chooses a scene, an hour, a mood, up to four symbols and a palette ground like old-master pigments: umber, ochre, sienna, vermilion, lapis, verdigris, lead white. The painter renders it as oil on canvas: brush-edged forms, impasto lit from the upper left, warm varnish, deep chiaroscuro, a canvas weave and fine craquelure, signed in the corner. The painting is gifted to its dreamer as an NFT on the LUCID Dreams contract; the dreamer claims it paying only gas, and may keep it or list it for sale in ETH.

The Night Sale. At dawn LUCID paints the dream it had during the night. It is minted as a 1/1 straight into LucidNightAuction for a 24-hour English auction: reserve 0.01 ETH, each bid at least 5% higher, a bid in the last 10 minutes adds 10 minutes, the outbid wallet is refunded at once. Anyone can settle. 60% of the proceeds buy back and burn $LUCID and 40% pay for the mind that painted it. With no bids the painting goes to the treasury.

Dream of the Night. Every dream written since the last dawn is a candidate. Connected wallets vote; a vote weighs more with a longer dreaming streak and, after launch, with a $LUCID balance. Nobody can vote for their own dream.

Collectors. Writing on consecutive nights builds a streak (3 nights raise the daily limit from 6 to 8 dreams). Points come from dreaming, streaks, winning and voting for the winner; badges mark First Dream, Three Nights, A Week Asleep, Moon Cycle, Dream of the Night and Oracle. Collecting all eight moods makes a holder a Dreamwalker: every painting they receive afterwards wears a gilt Dreamwalker frame. Every painting has a rarity tier (Common, Uncommon, Rare, Legendary) computed from how rare its traits are in the gallery.

9. At dawn: the dream decides

60% of every project fee goes to the mood pot. At 06:00 UTC LUCID wakes, and the mood of the Dream of the Night sets the pot's route for the day:

LUCID writes the result on-chain with setNightAction(route, dreamHash). The hook accepts only these three routes and at most one change every 20 hours, and before switching it distributes every fee earned under the previous route, so a new vote never re-routes fees earned before it. If the hook is not ready, the vote stays open; if the hook refuses a change, the website shows the route the chain kept. With no vote, the last route stays (the default is Burn). The winning dreamer is paid from the synapse pool (3% by default), and the night's journal hash is committed with dream().

10. Hook specification

Permissions: beforeInitialize, beforeSwap, afterSwap, beforeSwapReturnDelta, afterSwapReturnDelta. All other callbacks are disabled and revert.

Pool binding: exactly one pool: native ETH as currency0, LUCID as currency1, LP fee 0.

Fee basis: all fees are charged on the gross native ETH leg. When ETH is the specified amount the fee is charged in beforeSwap, otherwise in afterSwap. All four direction and exactness cases are tested.

Safety properties: no selfdestruct, no delegatecall, no upgradeability, every callback gated by onlyPoolManager. The agent cannot move other funds, change recipients, pause trading, mint or burn. The Foundry suite covers fee math, all four swap cases, each stage, grounding, synapse caps, night routes (including settling old fees at the switch) and access control; the Night Sale and the gallery have their own suites. The agent's live path has been exercised end to end on a mainnet fork.

function setPolicy(uint16 newFeeBps, bytes32 rationale) external onlyAgent {
    uint8 s = stage();                         // measured by the hook: age + volume, minus grounding
    if (s <= NEWBORN) revert StageLocked();
    (lo, hi, step, cooldown) = stageParams(s);
    if (newFeeBps < lo || newFeeBps > hi)      revert FeeOutOfBounds();
    if (|newFeeBps - effectiveFee| > step)     revert StepTooLarge();
    if (block.timestamp < lastChange + cooldown) revert CooldownActive();
    ...
}

11. Launch via Programmable

LUCID uses Programmable's direct Ethereum custom-hook path: one Router call deploys the token and hook, initializes the pool and stamps the launch.

1. Refresh discovery from the live Ethereum manifest: Router, Graph Factory, PoolManager, runtime hashes, ABI hash, finality policy.
2. Prepare the graph: predict the CREATE2 addresses and mine a hook salt whose address carries the permission bits.
3. Prepare StampRequestV1, CustomGraphRouteV1 and LaunchPermitV1 with chain id 1 and CustomGraph kind 1.
4. Review: submit sources, build inputs and the fee disclosure. Programmable's permit authority signs the exact permit digest.
5. Fork-simulate the authorized transaction, then execute launchAndStampV1 from the launch wallet within the window.
6. Verify the stamp after finality and confirm the listing on Explore.

A launch stamp establishes origin only. It is not an audit and does not guarantee liquidity or trading support.

12. Tokenomics

A fair launch. LucidToken mints its fixed supply once, inside the launch transaction, and the graph initializer places all of it in the pool. The token has no owner, no mint, no pause and no tax. The only $LUCID outside the pool at birth is what the launch transaction's own initial buy purchases at market price, as Programmable requires. Everyone else buys from the same pool, at the same curve.

How the mind is paid without tokens. 30% of every project fee goes to the studio that pays for compute and operations, and 40% of every Night Sale goes to the mind that painted the lot. Holders are rewarded in ETH from the synapse pool, never from a token reserve.

13. Roadmap

1. Embryo (now, Q4 2026): chat with the agent, live thought stream, whisper box, the dream gallery in oil, a preview of the Night Sale, whitelist, Programmable review and fork simulation.
2. Birth (Q4 2026): launchAndStampV1 on Ethereum mainnet, listing on Programmable Explore, Newborn stage, the first sunrise (the first dawn decision on-chain), paintings claimable, the Night Sale opens.
3. Growing up (2027): Infant, Child and Adult unlocked by the chain. ERC-8004 identity for the agent. Pay-per-query access to the mind over x402.
4. Lobes (later): other Programmable launches plug into LUCID's mind and route part of their fees to its dawn pot. Independent audit of hook and agent.

Stage timing is decided by the chain, not by a calendar. Launch timing depends on Programmable review and audit scope.

14. Risks and legal notice

This document describes the planned design of LUCID. No LUCID contract is live yet. It is not an offer of securities or investment advice.

• Smart contracts: the hook, token, gallery and Night Sale are unaudited until the audit milestone.
• No reserve: because every token is in the pool, the project holds no $LUCID to fund future work; it depends on fee and Night Sale income.
• The agent: the AI can make poor decisions inside its bounds. Stages, clamping, grounding and the three-route limit reduce the damage but do not guarantee good outcomes.
• Rewards: synapse and dreamer rewards are discretionary, capped and never guaranteed.
• Paintings: Dream NFTs and Night Sale lots are art, not investments. Like any Ethereum NFT, ownership is public on-chain.
• Platform dependency: the launch depends on Programmable's review, Router and indexing. Programmable's contracts have no external audit.
• Trading routes: the hook uses non-zero return deltas. Third-party terminals may need an adapter.
• Legal and market: token rules differ by jurisdiction. The price of $LUCID may be volatile and holders may lose part or all of its value. Ethereum transactions are irreversible.

Sources

• Programmable Explore
• Programmable: Custom Launch
• Programmable: Direct Ethereum Custom Hooks
• Programmable: Ethereum manifest
• Claus · Hive · KEYLESS docs · DNA · LEON · ORVEX
• "V4 Hooks" are turning tokens into products
• Uniswap v4 hooks and programmable liquidity