These are some general questions i received from my friends after they used coldstart, writing them below in case it helps !

[AkashGoenka]

Q1: Does this prevent the agent from reading files directly? If coldstart handles navigation, does it stop the agent from grepping or opening files on its own? Or is it more of a suggestion it can ignore?

Answer:
No — coldstart never blocks or intercepts anything. The agent can always grep, open files, or ignore coldstart entirely, and it often will.

I tried gating that behavior early on (hooks that fire before a search tool runs) and it doesn't hold up — a shell call containing grep slips right past a hook registered on the "official" search tool, and even when the interception works, steering the agent's choices with instructions just doesn't stick. Advisory rules get ignored or pattern-matched around.

So the design gave up on steering entirely. find and gs just make the fast path faster — ranked results with the matching lines shown inline, so the agent often doesn't need to open the file at all. If it reaches for grep instead, that's a normal outcome, not a failure. The goal is that when coldstart is called, the answer is good enough to end the question in one turn.

---

Q2: How are the generated notes actually used by the agent? Once a note exists in the notebook, how does it get back in front of an agent later? Does it have to ask for it specifically?

Answer:
Notes are surfaced automatically at the start of a turn when they're relevant to what's being worked on — not pulled up only on request. A note that has to be explicitly asked for is a note that basically never gets read.

The more important part is what happens before it's shown. Every note is anchored to the actual files and symbols it's about, stamped with a content hash at the moment it was written. When the note is about to surface, that anchor gets re-checked against the current code. If nothing's moved, the note is shown and can be trusted without re-opening the file. If the underlying code has changed, it renders as [evidence changed] and drops down instead of being presented as settled fact.

So "how it's used" is really: injected automatically when relevant, but gated by whether the code it's based on is still true.

---

Q3: How can I see the notes that have been written so far? Is there a way to browse what's actually in the notebook, or is it only consumed by the agent?

Answer:
coldstart kb view opens a local browser view of the whole notebook — every note, what files and symbols it's anchored to, and its current freshness state (fresh vs. [evidence changed]).

It's entirely local by default; nothing leaves your machine. If you want to share it with a team, there's a separate command to commit the notebook to the repo as an append-only log — until you run that, it's just yours.

---

Q4: Doesn't writing notes increase cost, since output tokens are more expensive than input? Having the agent stop and write a note sounds like it adds extra output on top of the task it was already doing. Given output tokens cost more per token than input, doesn't that add up?

Answer:
Fair question, and worth being precise about, because the intuition is reasonable but the arithmetic doesn't actually work out that way.

Output being pricier per-token is true, but it's a small fraction of what a session actually bills for overall — the dominant cost is resident context getting re-sent and re-billed on every subsequent turn, not what the model writes in any single turn. A note is generated once, at the end of a task, and only when there's real signal that something worth keeping was learned — not after every task.

Compare that one-time, modest output cost against what it's replacing: without the note, the next session that touches that same area re-does the full investigation from scratch — re-reading the same files, re-tracing the same logic, at full resident-context cost, every single time the question comes up again. The note is a small write now that avoids a much larger re-read cost, repeated indefinitely, later.

So yes, the turn where a note gets written costs a little more in isolation. Across the life of the repo, it's cheaper.