Sessions that keep the thread

A long session in most coding agents grows an ever-larger context until it slows down, costs more per step and finally has to be summarized, and the summary loses the one thing you needed. Ocean Code does not work that way.

The tideline

Ocean Code works from a bounded window. The model always sees the newest part of your conversation. When the window reaches the tideline, the oldest turns move past it: out of the model's view, not out of your session.

Nothing past the tideline is summarized or thrown away:

• Every turn is kept word for word in the session's transcripts on disk, each with a stable address.
• A ledger page, SESSION.md, keeps the goal, the decisions and why, your constraints, environment facts, errors and their fixes, a code map, open questions and the next step, each line stamped with the turn it came from. The engine writes the facts it already holds (files touched, commands and exit codes, tasks); the agent adds what it learns. The page is edited, never rewritten, so a reversed decision keeps its old text struck through.
• The agent recalls instead of guessing. When it needs something from earlier, an exact error string, a rule you gave once at the start, the reason behind a choice, it looks it up in the ledger. In the live checks, a turn that had moved past the tideline came back through the ledger when asked for.

The session ledger is the subject of a US provisional patent application; the technology is patent pending.

What you get

• A session that stays fast and affordable however long it runs: every request stays under the limit you set, and the prompt cache keeps working between cuts.
• Hours of work and hundreds of steps in one go. A measured session of 523 steps over 84 minutes, 52 turns past the tideline, finished 91 of 91 plan rows; five constraints stated once in the first turn were restored from the ledger page after an hour of drift. Real sessions of 400 steps and more run the same way.
• Windows that stay open for days, and a session you can reopen days later with its history intact: a 2,500-row session loads in about a third of a second.
• Nothing you have to set up. The ledger is on from the first turn of every session.

What you see

The status bar's context row measures the window against the model's own context and marks the tideline on its gauge:

tideline @40% (400k): 238k to go

It is green under 80 % of the limit, yellow from 80 % and orange at the line. Once turns have moved past the tideline the row counts them, tideline ×12 @40% …; tideline off means the ledger is disabled. /context shows the same meter with the session's token counts and spend. Details in the pager reference.

What you control

One number: where the tideline sits, as a share of the model's context (ledger.tideline.percent, default 40) or as a fixed limit.

A change applies from your next message on. Headless, the same setting is --tideline "<percent>% | <limit> | default"; a sub-agent inherits its parent's setting. The config keys are in the configuration reference.

What you can rely on

• The record stays as long as the session. Idle sessions are kept 7 days by default (retention.days, /retention); deleting a session removes its transcripts and ledger page with it (operations).
• Undo is real. /undo reverts the conversation to an earlier message and puts back every file the later turns changed through the file tools; /redo re-applies them.
• You can take it all with you. oceancode export <session-id> --md writes the whole session as one Markdown document; --atif writes a trajectory file for evaluation tools (CLI reference).
• Nothing is sent that you did not write. The ledger page and the transcripts live on your Mac, under ~/.local/share/oceancode/session-ledger/<session-id>/.

Next

• Long runs and sub-agents: the bounds that end a run, and the plan that drives it.
• Several sessions, one Mac: reopening any session by its code.
• The reference: Session ledger and export.