Immediate context compaction and hallucinations on first prompt with large codebase

[hashen10]

Hi everyone,

I'm running into a major bottleneck when starting a new session with a medium-to-large codebase.

On the very first instruction/prompt, the initial context ingestion immediately shoots up to around 70% capacity. Because it's so high, the model instantly triggers context compaction before it even begins executing the actual work. As a result, the model starts hallucinating right from the start of the session due to the aggressive compaction.

• Is anyone else dealing with immediate compaction on session start?
• Is there a way to adjust the compaction threshold or optimize how the initial codebase context is loaded to prevent this?

Any advice or workarounds would be highly appreciated!

[starkmarkus]

This sounds like the initial repository context is too broad.

If the first prompt already fills ~70% of the context window, then compaction is almost guaranteed to be lossy. At that point the model is summarizing a lot of code before it has even understood the actual task, which is a good recipe for wrong assumptions and hallucinations.

I would try to avoid loading the whole codebase into the first turn. The better pattern is usually:

• start with only repo structure + the specific files relevant to the task
• exclude generated files, build outputs, lockfiles, vendor folders, snapshots, etc.
• let the agent search/open files on demand instead of preloading everything
• ask it to first identify relevant files, then plan, then edit
• keep large documentation/code dumps out of the initial prompt unless they are directly needed

A first prompt could be something like:

Do not ingest the full repository upfront.
First inspect only the directory structure and identify the minimal set of files relevant to this task.
Open files incrementally as needed.
Before editing, summarize which files are relevant and why.
If context usage gets high, stop and ask before compacting.

If OmO has a configurable context/compaction threshold, it would be useful to expose that. But I think the bigger issue is not just the threshold; it is that compaction is happening before the model has a task-specific understanding of what matters.

So I would look for settings around:

• ignored paths / context exclusions
• max files or max tokens for initial repo load
• disabling automatic full-codebase ingestion
• retrieval/search-based context loading
• compaction threshold / manual compaction mode

If those settings do not exist today, this feels like a good feature request: the first prompt on a large repo should not automatically trigger aggressive compaction. A safer default would be lazy context loading plus explicit warnings when the initial context is too large.