> Marc Andreessen was right about web browsers.

> But he has since been wrong about a great many things.

This is true for almost all of the tech bros / influencers / CEOs. Being right once and getting rich does not make them smarter or better than anyone. Unfortunately our society doesn‘t view it that way - hence here we are, stuck with the Elons and Thiels of the world. And it‘s hurting us yet they’re on a pedestal

Ha, we both reacted to the same 2 sentences in a very similar way at basically the same time!

Exactly. They just happened to be there at the start of the wave and bam they're geniuses. No they're just greedy a-holes and leeches!

Can someone explain to me what this is / how it works - the readme is barely understandable for me and sounds like LLM gibberish. What is ambiguity front loading even?

<< memory-stored interaction protocols combined with incremental escalation prompts produced cumulative character drift with zero self-correction.

They don't seem to provide explicit examples, but the same was roughly true with chatgpt 4o, where, if you spent enough time with the model ( same chat - same context - slowly nudging it to where you want it to be, you eventually got there ). This is also, seemingly, one of the reasons ( apart from cost ) that context got nuked so hard, because llm will try to help ( and to an extent mirror you ).

And this is basically what the notes say about weaponized ambiguity[1]:

'Weaponizes helpfulness training. "I don't understand" triggers Claude to try harder.'

In a sense, you can't really stop it without breaking what makes LLMs useful. Honestly, if only we spent less time crippling those systems, maybe we could do something interesting with them.

[1]https://nicholas-kloster.github.io/claude-4.6-jailbreak-vuln...

I see - so essentially „context rot“ eventually leads the LLM to „forget“ safety guardrails?

To an extent, because, based on github notes again, it seems the 2nd part of this jailbreak is model being 'confused' over prompt, because the prompt is - apparently - sufficiently ambigous to make model 'forget' to 'evaluate' message for whether it should be rejected, and move onto 'execution' stage.

That's the ambiguity front-loading; and that is why I referred initially to the long context, because here it is almost the opposite; making context so small and unclear, that the model has a hard time parsing it properly.

edit: i did not test it, but i personally did run into 4o context issue, where model did something safety team would argue it should not

edit2: in current gpt model, i am currently testing something not relying on ambiguity, but on tension between some ideas. I didn't get to a jailbreak, but the small nudges suggest it could work.

Does this solve indexing of codebases like Cursor does, or do you still need tools / plugins like Lumen (https://github.com/ory/lumen) for that in order to work in larger codebases without wasting tens of thousands of tokens on tool calls and brute force guessing with grep?

ctx sits around the agent harness, not in place of it.

So Claude Code, Codex, OpenCode, etc keep their normal tools/capabilities rather than being reimplemented inside a new proprietary agent. If a harness has its own indexing/code-search story, you still get that; if it doesn’t, ctx doesn’t provide additional tools like codebase indexing.

The only additional tools we do provide are orchestration-related: - local merge queue for agents (submit your diff and make sure it lands cleanly on others) - agnostic subagents (for example, a Claude Code primary agent can invoke a Codex subagent)

how does lumen differ from serena? https://github.com/oraios/serena curious about it seems promising

Serena is more about text editing and better code search tooling while lumen is (a) chunking code with tree sitter and (b) storing embeddings (vectors) generated by an embedding model (ideally ones which are for code) which you then can search against. Effectively it‘s RAG for code made available as an MCP server.

This reduces tool calls (and thus saves times and tokens) because instead of „trying“ / „guessing“ names repeatedly, tools like claude code typically get useful search results on the first try.

Claude for example may search for „dbal“ via regex, but the function name is „sql“ - semantic search will find that while for regex, claude would try 3 additional guesses before it actually finds what its looking for. Hope this helps!

Oh thank you for the detailed response, that makes perfect sense, appreciate it and will certainly give it a try now!