naamo @othomo

@m_blm_tw @grok ?

@SalahBaina @Souta_knave Just an other fancy wrapper.

I went through Claude Code's codebase with the help of AI to analyze the architecture quickly and compare it against Codex which is already open source. I'm very interested in this space because agentic coding is essentially what we're building at Firassa AI but for video editing. Not the "move this clip" or "add a transition" kind of agentic, but a full autonomous agent that takes raw footage and delivers a rough cut that could be production ready. So understanding how these agentic loops are designed matters a lot to me. The biggest misconception in the Claude Code vs Codex debate is that Claude wins because the model is smarter. Through my own use cases and looking through people's feedback, Codex is actually the stronger coder on harder tasks. Claude wins because it built a better control plane. Claude Code is built around a centralized turn loop that behaves like a state machine. You can look at src/query.ts and see it acting as the center of orchestration, with src/bootstrap/state.ts as a giant centralized session-state layer around it. Every phase of the agent loop (preparing context, sampling the model, executing tools, waiting on the user, compacting) flows through that center. That's why it feels smoother. You always know what it's doing. Codex spreads that same logic across submission_loop, user_input_or_turn, RegularTask::run, and run_turn in different files. RegularTask::run literally just loops run_turn until has_pending_input() goes false. It works but the states are emergent not declared. One of my biggest issues with Codex has been not knowing when it's actually waiting on me versus still thinking, and looking at the architecture now I understand exactly why. Tool scheduling is where Claude quietly destroys Codex on speed in the main agent loop. Claude clearly separates read-only, edit, execution, and MCP tool classes at the product level, and you can see toolOrchestration.ts and StreamingToolExecutor.ts handling batching and ordered result streaming. Codex has a solid per-tool orchestrator in tools/orchestrator.rs with approvals and sandbox retries, arguably better low-level rigor. But in the main turn-level orchestration path it processes tools through a per-call approval, sandbox, attempt, retry pipeline without a first-class batch scheduler or concurrency graph. Worth noting though that Codex already has parallel nested tool execution inside code mode through exec/wait, where JavaScript runs in a V8 isolate and can compose and parallelize nested tool calls. So the gap is specifically in the main agent loop, not across the board. Context management is Claude's most underrated advantage. From the codebase you can see exactly what loads when. CLAUDE.md at session start, skill descriptions lazily, MCP schemas deferred, subagent context isolated, hooks at zero cost unless they emit. There's a real context economy with visible budgets and you can trace it through the /context and compact modules. Now to be fair Codex is not missing context plumbing. It already has repo-aware startup context in realtime_context.rs, explicit AGENTS.md discovery in project_doc.rs, and compaction logic in compact.rs that handles reinjection of initial context. But that's exactly what makes the critique sharper. The real gap is not missing components. It's that there's no single governor deciding what stays what gets summarized what gets retrieved. A lot of people on GitHub are asking for semantic indexing which basically means they want that governor layer even if they don't call it that. File editing is where the architectures diverge most interestingly. Claude uses optimistic-concurrency editing through FileEditTool. Read a file, record the revision, propose a localized edit with old_string/new_string, detect staleness, show a diff for approval. The IDE side has real diff editing flow through FileEditPermissionRequest.tsx and ideDiffConfig.ts. It's a trust primitive not just an edit primitive. Codex is patch-first and honestly its patch engine is better. TurnDiffTracker in turn_diff_tracker.rs maintains baselines, handles renames, generates unified diffs. It also already has diff approval primitives, the TUI has an approval_overlay that handles ApplyPatch requests and the app-server protocol has explicit file-change approval request/response types. So the gap is not that Codex has no review surface. It's that it doesn't have the same revision-aware localized edit contract or a first-class editor-side diff editing loop. The fix isn't to throw away the patch engine. It's to wrap it in that narrower revision-aware contract on top. Permissions are where Codex has real bugs not just missing features. Both have tiered permission systems and sandbox enforcement. Codex even has a guardian reviewer and it's more sophisticated than it sounds. It reconstructs a compact transcript, runs a dedicated review session, requires strict JSON output, fails closed on malformed output or timeout, and only auto-approves lower-risk actions. That is genuinely strong low-level rigor. But from looking at the issue tracker and community feedback, the layers leak in practice. MCP edit tools can bypass read-only mode. Approval state reverts after thread switches. Network retries after approval still inherit restricted policy. Child workers don't pick up parent permissions correctly. The result is inconsistent behavior where the same approval means different things depending on which execution path the agent takes, and that's a trust killer. Planning is Claude's highest-leverage UX win and Codex's biggest missed opportunity. Claude has first-class plan mode, plan approval surfaces, and built-in planAgent and verificationAgent sitting right there in the source. That's not just prompting, that's architecture. Codex has multi-agent primitives, mailboxes, agent registries, even the guardian reviewer. All the pieces for a planner-verifier pipeline exist. They just haven't been assembled into a workflow users can rely on. Now here's where it gets interesting because I think Codex has at least 5 ways to actually get ahead of Claude architecturally. Open retrieval backends. Claude's context economy is well designed but the retrieval architecture is still proprietary internally. Codex can expose a RetrievalIndex trait and let the community build BM25, embeddings, tree-sitter, hybrid backends. I think that's the kind of advantage you can only get by being open source. Deterministic replay. Codex's persistence story is even stronger than just a SQLite DB. The state runtime opens and migrates dedicated SQLite state and logs databases separately to reduce lock contention, and the migration history tracks threads, logs, memories, dynamic tools, spawn edges and more. That's a better foundation than Claude's in-memory singleton for testing and CI. Turn that into a flagship feature. Guardian plus Verifier stack. Combine the existing safety reviewer with adversarial post-change verification. Policy review plus correctness verification is stronger than either alone. Structured plan artifacts. Plans, approvals, verification reports all want schemas not prose. OpenAI's structured outputs are a natural fit here and Codex could have this working before anyone else does. Community policy packs. Codex can let the community publish not just tools but safety and verification behavior. I think that's a way more interesting competitive advantage than keeping everything internal. Codex code mode is also a real sleeper in this whole conversation. exec/wait gives you a programmable orchestration layer where JavaScript runs in a V8 isolate, composes nested tool calls, can persist values across calls, and parallelize work. I think that's a real path for Codex to get ahead of Claude instead of just copying its control plane design. If I wanted to get Codex to actually compete on the orchestration level I'd start with three things. A TurnStateMachine. An EffectivePermissionContext. A ToolExecutionGraph. Those fix the control plane. Everything else becomes dramatically easier to build after that. I think Claude Code wins on orchestration, context policy, permission UX, and the extension story. Codex wins on low-level rigor. Rust core, real OS sandboxing, better patch engine, stronger persistence substrate, and code mode as a programmable orchestration primitive. Codex's problem is that its backend primitives are ahead of its orchestration layer. It's a product with P0 infrastructure and P2 choreography. The winning move for OpenAI is to put a first-class control plane on top of the Rust core they already have.

@mahamiou @grok, what are those chemical materials?

This is extremely bad news for MRI machines. (That’s something I learned in Cuba, where it’s hard for them to get helium for their machines.)

zerohedge @zerohedge

3 months ago

AirGas Declares Force Majeure On Helium Shipments As Qatar Production Collapses zerohedge.com/markets/airgas…

97 979 3K 452K 373

Really great writeup

Thariq @trq212

3 months ago

x.com/i/article/2033…

388 2K 16K 6.9M 44K

@alilakrakbi @grok double Check ?

@netdur @marouane53 You can mix them: use CC (Sonnet for speed) primarily, and use Codex for planning and review.

@cyclebrkr @amaan8429 same

@alilakrakbi Good luck

@MarkOU1 @WeTheBrandon @grok ?

LLMs process text from left to right — each token can only look back at what came before it, never forward. This means that when you write a long prompt with context at the beginning and a question at the end, the model answers the question having "seen" the context, but the context tokens were generated without any awareness of what question was coming. This asymmetry is a basic structural property of how these models work. The paper asks what happens if you just send the prompt twice in a row, so that every part of the input gets a second pass where it can attend to every other part. The answer is that accuracy goes up across seven different benchmarks and seven different models (from the Gemini, ChatGPT, Claude, and DeepSeek series of LLMs), with no increase in the length of the model's output and no meaningful increase in response time — because processing the input is done in parallel by the hardware anyway. There are no new losses to compute, no finetuning, no clever prompt engineering beyond the repetition itself. The gap between this technique and doing nothing is sometimes small, sometimes large (one model went from 21% to 97% on a task involving finding a name in a list). If you are thinking about how to get better results from these models without paying for longer outputs or slower responses, that's a fairly concrete and low-effort finding. Read with AI tutor: chapterpal.com/s/1b15378b/pro… Get the PDF: arxiv.org/pdf/2512.14982

Shifting structures in a software world dominated by AI. Some first-order reflections (TL;DR at the end): Reducing software supply chains, the return of software monoliths – When rewriting code and understanding large foreign codebases becomes cheap, the incentive to rely on deep dependency trees collapses. Writing from scratch ¹ or extracting the relevant parts from another library is far easier when you can simply ask a code agent to handle it, rather than spending countless nights diving into an unfamiliar codebase. The reasons to reduce dependencies are compelling: a smaller attack surface for supply chain threats, smaller packaged software, improved performance, and faster boot times. By leveraging the tireless stamina of LLMs, the dream of coding an entire app from bare-metal considerations all the way up is becoming realistic. End of the Lindy effect – The Lindy effect holds that things which have been around for a long time are there for good reason and will likely continue to persist. It's related to Chesterton's fence: before removing something, you should first understand why it exists, which means removal always carries a cost. But in a world where software can be developed from first principles and understood by a tireless agent, this logic weakens. Older codebases can be explored at will; long-standing software can be replaced with far less friction. A codebase can be fully rewritten in a new language. ² Legacy software can be carefully studied and updated in situations where humans would have given up long ago. The catch: unknown unknowns remain unknown. The true extent of AI's impact will hinge on whether complete coverage of testing, edge cases, and formal verification is achievable. In an AI-dominated world, formal verification isn't optional—it's essential. The case for strongly typed languages – Historically, programming language adoption has been driven largely by human psychology and social dynamics. A language's success depended on a mix of factors: individual considerations like being easy to learn and simple to write correctly; community effects like how active and welcoming a community was, which in turn shaped how fast its ecosystem would grow; and fundamental properties like provable correctness, formal verification, and striking the right balance between dynamic and static checks—between the freedom to write anything and the discipline of guarding against edge cases and attacks. As the human factor diminishes, these dynamics will shift. Less dependence on human psychology will favor strongly typed, formally verifiable and/or high performance languages.³ These are often harder for humans to learn, but they're far better suited to LLMs, which thrive on formal verification and reinforcement learning environments. Expect this to reshape which languages dominate. Economic restructuring of open source – For decades, open-source communities have been built around humans finding connection through writing, learning, and using code together. In a world where most code is written—and perhaps more importantly, read—by machines, these incentives will start to break down.⁴ Communities of AIs building libraries and codebases together will likely emerge as a replacement, but such communities will lack the fundamentally human motivations that have driven open source until now. If the future of open-source development becomes largely devoid of humans, alignment of AI models won't just matter—it will be decisive. The future of new languages – Will AI agents face the same tradeoffs we do when developing or adopting new programming languages? Expressiveness vs. simplicity, safety vs. control, performance vs. abstraction, compile time vs. runtime, explicitness vs. conciseness. It's unclear that they will. In the long term, the reasons to create a new programming language will likely diverge significantly from the human-driven motivations of the past. There may well be an optimal programming language for LLMs—and there's no reason to assume it will resemble the ones humans have converged on. TL; DR: - Monoliths return – cheap rewriting kills dependency trees; smaller attack surface, better performance, bare-metal becomes realistic - Lindy effect weakens – legacy code loses its moat, but unknown unknowns persist; formal verification becomes essential - Strongly typed languages rise – human psychology mattered for adoption; now formal verification and RL environments favor types over ergonomics - Open source restructures – human connection drove the community; AI-written/read code breaks those incentives; alignment becomes decisive - New languages diverge – AI may not share our tradeoffs; optimal LLM programming languages may look nothing like what humans converged on ¹ x.com/mntruell/statu… ² x.com/anthropicai/st… ³ wesmckinney.com/blog/agent-erg… ⁴ github.com/tailwindlabs/t…

Anthropic @AnthropicAI

5 months ago

New Engineering blog: We tasked Opus 4.6 using agent teams to build a C compiler. Then we (mostly) walked away. Two weeks later, it worked on the Linux kernel. Here's what it taught us about the future of autonomous software development. Read more: anthropic.com/engineering/bu…

855 2K 21K 8.5M 9K

Accord du Conseil de la concurrence à SICDA, filiale de CMGP, pour prendre le contrôle exclusif de GCP Plast via l’acquisition de 49,99 % de son capital.

I'm Boris and I created Claude Code. I wanted to quickly share a few tips for using Claude Code, sourced directly from the Claude Code team. The way the team uses Claude is different than how I use it. Remember: there is no one right way to use Claude Code -- everyones' setup is different. You should experiment to see what works for you!

@plamen_9 Waiting for apexlang to integrate apex ui into Claude code workflow’s #orclapex

@lghezouani @grok ?

@LailaMechbal @thescreenlad @grok ?

@bryan_johnson @grok what are the ingredients in this pic ?

@marouane53 @FourKites I confirm