Determined AI

Determined AI AI

Determined AI AI

Determined AI AI

Determined AI AI

Determined AI AI

Determined AI AI

Determined AI AI

Determined AI AI

Determined AI AI

Determined AI AI

Cerebras Chip Sets Appear to be Optimized for LLM Use Cases

One distinction I think is getting lost in the [Cerebras hype cycle](https://finance.yahoo.com/sectors/technology/articles/cerebras-challenges-nvidia-chip-dominance-040100169.html?guccounter=1) is that Cerebras is primarily an LLM / generative AI infrastructure story, not a universal “all AI” chip story. That is not necessarily a criticism of Cerebras. Their wafer-scale approach is genuinely interesting, and for large model training and inference the design is compelling. [Cerebras’ own public inference materials](https://inference-docs.cerebras.ai/models/overview) discuss applications mostly centered on open [LLMs such as Llama, Qwen, GLM, and GPT-OSS](https://www.cerebras.ai/infcamp). The inference metrics are [expressed in tokens per second](https://www.cerebras.ai/press-release/cerebras-launches-the-worlds-fastest-ai-inference), which is fundamentally a language-model / generative inference framing rather than a robotics or industrial-control framing. **What Kind of AI Compute?** But “AI compute” is not one undifferentiated market. LLM inference is one class of AI compute. Robotics, autonomous vehicles, drones, industrial controls, real-time vision, embedded perception, video pipelines, and sensor-fusion systems are very different classes of AI compute. Thus, it appears from Cerebras’ own materials that their chip sets are not optimized for what comes after LLMs, such as JEPA-style World Models or other post-transformer architectures. Those systems are not merely asking, “How fast can I generate tokens?” They often care about power envelope, edge deployment, ruggedization, latency determinism, camera/radar/lidar integration, feedback loops, safety certification, and real-time physical control. [Cerebras’ own CS-3 messaging](https://www.cerebras.ai/blog/cerebras-cs3), by contrast, frames the system around accelerating “the latest large AI models,” and the testing data is from the likes of Llama 2, Falcon 40B, MPT-30B, and multimodal models, again measured through tokens/second style throughput. **The Chip Hierarchy** This is also where the hardware distinction matters. Specialized ASICs are [usually the narrowest bet](https://www.hilscher.com/service-support/glossary/application-specific-integrated-circuit): if the workload matches the chip, they can be extremely efficient, but that [efficiency comes from specialization](https://www.synopsys.com/glossary/what-is-asic-design.html). Cerebras [appears broader than a narrow single-use ASIC](https://inference-docs.cerebras.ai/models/overview), but still much more concentrated around datacenter large-model training and inference. NVIDIA GPUs, by contrast, [are less specialized](https://www.nvidia.com/en-us/) but much [more broadly useful ](https://developer.nvidia.com/cuda)across AI workloads, including LLMs, vision, robotics, simulation, [autonomous systems](https://www.nvidia.com/en-us/industries/robotics/), edge AI, and industrial applications. So the question is not merely whether Cerebras is “better” or “worse” than NVIDIA. The question is what part of the AI hardware market we are talking about? **Challenge NVIDA?** This is why I think people should be careful when saying Cerebras is going to “challenge Nvidia” without specifying the battlefield. Challenge Nvidia in what? High-speed LLM inference? Large model training? Datacenter generative AI workloads? That is a much more plausible and specific claim. Cerebras has [even published and promoted work](https://www.cerebras.ai/whitepapers) specifically on training large language models, and [independent benchmarking literature](https://arxiv.org/abs/2409.00287) also evaluates Cerebras WSE in terms of LLM training and inference performance. **The Distinction that's Necessary** The point is not that Cerebras is overhyped. The point is that it is important in a specific part of AI and that distinction should be made clear. Cerebras may become a very serious player in LLM infrastructure, especially if the market continues to reward faster and cheaper LLM inference. But that does not mean it is positioned the same way across non-LLM AI. The current hype cycle tends to conflate "LLMs" and general “AI” compute together and that makes the hardware discussion less useful and clear. So ultimately, an investment in Cerebras looks more like a bet on current LLM infrastructure than a broad bet on the future form of AI. It may be a good bet, but people should understand what kind of bet it is.

Banned by OpenAI after reporting a live credential hijack. They admitted in writing my account was broken. Here are 7 months of forensic receipts and 20+ cases.

[Drive Link for Zipped Proof](https://drive.google.com/file/d/1qU_LyLY-JMhNR_bqOV1-a2RJAbplL68e/view?usp=drivesdk) I am a developer and paying long term subscriber to ChatGPT since January 2025. I build complex local first sovereign systems. My workflows are incredibly context heavy with large files spanning code, research reports, and other analysis. I do not, or rather did not as the platform has been non functional since November 2025 meanwhile customer support is auto closing tickets, admitting I am having platform issues. I do not use this platform for casual queries, as a solo developer with no formal "team" chatgpt was one of my reliable co collaboration hubs to help ensure I am maintaining proper development of said complex systems. I feed it massive codebases for systems analysis and obtaining new insights I may personally have missed. My manual code uploads and token inputs routinely exceed the model's output volume by a massive margin. I do not abuse this platform. It is actually impossible as the very features advertised under the paid subscription do not work. I am exactly the type of user this platform was built for, and I have been a continuous, paying ChatGPT Plus subscriber since January 2025. Since October 2025, my workspace has been systematically breaking and beginning November 2025 total workspace degredation. This was not an occasional glitch. Persistent memory modules stopped updating. Custom instructions were ignored by the models. Project files failed to load. Custom instructions, personalization features, connector abilities, file tool, even projects do not work. It started as a continuous degradation until total failure. OpenAI customer service even admitted as such and yet months later I've talked to nothing but bots, not only LLMs as customer service but even instances of falsely identifying as true human support. It was a state of rolling degradation across the entire paid tier, month after month. Meanwhile OpenAI freely has enhanced for businesses and enterprise tiers. I have not just rapid complained to standard support. I ran and obtained cross platform diagnostics, failure logs. I even documented and told oai customer support the exact replication steps only to be met with acknowledgement of degredation with no resolution. I handed OpenAI support a completely packaged technical breakdown of their failing infrastructure across 20 separate support tickets over a 7 month period. I did their QA work for free. And I have the receipts to prove it. I am attaching the screenshots and the exact email files to this post. In Case 06830839, OpenAI Support explicitly put this in writing: "We acknowledge that you have been experiencing persistent technical issues affecting several features of your ChatGPT subscription, including tools, memory functions, personalization settings, connectors, and project files... We also understand your concern that communication on the case stopped after you provided detailed evidence..." Read that again. They acknowledged in writing that my account was fundamentally broken. They acknowledged that their own team ghosted me after I handed them the diagnostic proof. Yet they kept charging my card every single month for a product they knew was failing. The Hijack Escalation: Two days ago, the situation escalated from a broken product to a severe security incident. I was monitoring my environment and watched my Codex rate limits drop in 10 percent chunks across 2 seperate sessions on a fresh boot of the desktop app. This happened twice inside a 10 minute window. I had zero active sessions running. There was zero usage on my end. My account token was being actively drained by an unauthorized third party exploit. I immediately opened an emergency unauthorized activity report under Case 09113391 to notify them of the hack. Their response was to totally reframe this problem as disputing fraudulent activity trying to do damage control of the situation and altering the record. The Reframe Attempts: Instead of investigating the breach, OpenAI support deliberately twisted the record. They not only deliberately reframed my security report as an "appeal for fraud." They manipulated the ticket classification to make it look like I had been flagged for fraud and was begging for an appeal, rather than a developer reporting a live exploit on their infrastructure. They ignored the active threat their own platform was exposing. They did not lock the token. They did not roll my API keys. They did absolutely nothing to secure a compromised paying user other than shift the blame. Fast forward to this morning, their automated Trust and Safety system swept the high volume traffic from the attacker, scored it as a malicious exploit originating from my account, and deactivated/banned me for "Cyber Abuse." All the while actively preventing chatgpt models from helping me try to disgnose and trace the infiltration. They locked the doors and blamed the homeowner for the

I read threads complaining about codex every week... tf are y'alls workflows?

For context: I'm a software eng @ a fortune 500/FAANG tier company. We use AI. We treat all ai code with humans as the bottleneck. That is: You generate AI code, you own it. It has bugs? It's your bug. Codex has only gotten better. 5.5 reasoning has only improved, albeit it thinks more. My question is: what the hell are y'all up to that I constantly hear things like codex broke and everything sucks? You need to review the code. YOU need to understand what codex outputs. AI is nondeterministic, so I don't know why people are creating agentic flows for deterministic work. Need determinism? Generate an audit the code man. What are people's workflows here that I constantly hear about degraded quality? Personally I just create plenty of skills and harnesses for information that it needs, I set off parallel tasks that are sandboxed from each other (E.g using a worktree, different folder, whatever your taste is), I review the code, I tweak it myself manually.. and that's it. At the end of the day, I've been a software engineer for 10 years, I understand anything codex generates is something I have to own and be able to debug eventually myself if the world suddenly gets rid of AI (which we know it won't, but it's the sentiment that should be held). I'm not coming from a place of reprimanding, truly I'm not, but I just don't see how it's gotten worse. I work on very high perf software and codex has helped a lot in saving me time on ASM analysis and algorithmic reasoning for things where throughput matters.

Live Human Detector on Outbound Phone Calls [R]

**Goal** To save humans wasting time sitting in Call Centre queues waiting to be answered To have tool listen in on the audio stream of a live call, post IVR Navigation - to determine whether the call has transitioned out of the queue and to a live person.  **Requirements** The tool must be able to classify the audio within a sub 1-2 seconds contextual window with as high confidence level as possible. This is not a typical AMD tool, we are not just detecting machine audio vs human speech   **Assumed Challenges** 1. It may be difficult to determine between a pre-recorded RVA (Recorded Voice Announcement) and a human speaking.  RVA typically are professionally recorded with distinct pitches and emotional queues, have clean audio with no background noise or silence before and after the message.  This is not always the case, especially if announcements are recorded in house by the general staff. 2. When a call is transitioning and 'Answered' there is usually a distinct soft click and or some background noise before the agent starts speaking.  This silence period, whilst a good indication a call has been answered could be confused with quiet periods between music or RVA announcements in the queue. 3. It may be difficult to determine if we have been answered by Voicemail - whilst there is usually a beep at the end, the message itself would also start with a silence period followed by audio sounding similar to an RVA. 4. A single short beep tone could mean Voicemail, Answered or it could mean the call is being recorded 5. Identifying we are in a queue based on TTS audio may be difficult to identify as TTS engines become more sophisticated 6. Telephony or G711a is in the frequency band of 300–3400 Hz @ 8000hz - 64 kbit/s   **Approach** To train via machine leaning using labelled data, an audio classification application that analyses the acoustics, wav form or spectrograph (via Fast Fourier Transform) of the audio stream At this stage I do not want to use STT to determine the phase or label - Although this will likely be added at a later stage as an additional layer in the pipline to increase confidence in some of these labels such as RVA/TTS/Voicemail/Call Screening    **Phase** **Queuing** *Labels* Music, TTS, RVA (Recorded Voice Announcement)   **Transitioning** *Labels* Ringback, Answered, Machine Beep   **Connected** *Labels* Human, Fax, Voicemail, Call Screening   **Disconnected** *Labels* Engaged Tone   **References** [https://www.mdpi.com/2076-3417/12/7/3293](https://www.mdpi.com/2076-3417/12/7/3293) \- YOHO You only here once [https://www.vicidial.org/VICIDIALforum/viewtopic.php?t=42330](https://www.vicidial.org/VICIDIALforum/viewtopic.php?t=42330) [https://huggingface.co/learn/audio-course/chapter2/audio\_classification\_pipeline](https://huggingface.co/learn/audio-course/chapter2/audio_classification_pipeline) [https://www.youtube.com/watch?v=m3XbqfIij\_Y&t=32s](https://www.youtube.com/watch?v=m3XbqfIij_Y&t=32s) [https://google-ai-edge.github.io/mediapipe-samples-web/#/audio/audio\_classifier](https://google-ai-edge.github.io/mediapipe-samples-web/#/audio/audio_classifier) [https://scikit-learn.org/stable/machine\_learning\_map.html](https://scikit-learn.org/stable/machine_learning_map.html) [https://arxiv.org/pdf/2410.08235](https://arxiv.org/pdf/2410.08235)   **Question** Seeking assisance on where to actually start.  Yes I be relying heavily on claude code to build this so apologies in advance What is the best framework / algo rhythm / approach to start solving this problem.  I have seen existing frameworks like YamNet work well and fast on classifying audio - however other suggest Whisper and ASR What is the best way of tagging or labelling data.  Do I label existing full length recordings with stop/start timestamps or each label or do I need to split each label into its own file - resulting in a loss of context.  Are there obvious existing data sets I should be using for some of my labels

OpenAI claims a general-purpose reasoning model found a counterexample to Erdos's unit-distance bound [D]

OpenAI posted a math result today claiming that one of its general-purpose reasoning models found a construction disproving the conjectured n\^{1+O(1/log log n)} upper bound in Erdős’s planar unit-distance problem. Announcement: [https://openai.com/index/model-disproves-discrete-geometry-conjecture/](https://openai.com/index/model-disproves-discrete-geometry-conjecture/) Proof PDF: [https://cdn.openai.com/pdf/74c24085-19b0-4534-9c90-465b8e29ad73/unit-distance-proof.pdf](https://cdn.openai.com/pdf/74c24085-19b0-4534-9c90-465b8e29ad73/unit-distance-proof.pdf) Abridged reasoning writeup: [https://cdn.openai.com/pdf/1625eff6-5ac1-40d8-b1db-5d5cf925de8b/unit-distance-cot.pdf](https://cdn.openai.com/pdf/1625eff6-5ac1-40d8-b1db-5d5cf925de8b/unit-distance-cot.pdf) The mathematical claim, as I understand it, is that there are finite planar point sets with more than n\^{1+δ} unit distances for some fixed δ > 0 and infinitely many n. That would rule out the expected near-linear upper bound, though it does not determine the true asymptotic growth rate. What seems especially relevant for this subreddit is the process claim: OpenAI says the solution was produced by a general-purpose reasoning model, then checked by an AI grading pipeline and reviewed/reworked by mathematicians. The proof PDF also includes the original prompt given to the model, but not the full experimental details: no model name, sampling setup, number of attempts, compute budget, hidden system prompt, or full grading pipeline. Curious how people here read this as an ML result. Is this best viewed as evidence of frontier models doing genuine autonomous research, or as a cherry-picked but still important sample from a large search process? What kind of disclosure would you want before treating this as a reproducible AI-for-math milestone?

Could AI be indirectly addressing the imbalance in equality of opportunity due to our differences in IQ?

I had been thinking about how schools work when I realised it seems as though you're first taught how to work then why to do the work. I think that was a perfectly reasonable mode of operation at the time formal education was being introduced because it wasn't at a time when we were exactly as skeptical as we are now about the corrupt foundations of our systems of authority. This is to say that, back then, because of how high stakes survival was, people weren't so comfortable existing without order. This also isn't to say that established order is perfect, and nothing of value can be found through exploration, but in fact to say that this is how innovations come to be, and that there was a lot more respect for keeping things in order because the other option was effectively desperation. Nowadays, with the justification upon which western and westernised civilisations developed being shaken, as in the belief in Judeo-Christian values, the established order seems archaic, which is usually the first step towards a sweeping change, which could be revolutionary improvement or a flood. Why does that matter? While I believe getting entirely rid of the influence that our foundational belief has on our culture would be catastrophic, i don't think there are no improvements to be made and in fact can't conceptualise the point where there exists no improvement). Think of the foundational belief/philosophy of 'Loving the Lord your God (which I understand as having the utmost respect for pure truth which leads to true love) and then loving your neighbour as you love yourself' as a current that carries us through time. Some currents are full of rocks while some provide safe passage. This current has led to the greatest civilisation man has recorded thus far. So to get rid of surfaces you can do without to further avoid collisions is what we're supposed to do. We're now at a point where 'switching streams' seems to be a central focal point of cultural, political and philosophical conversations, meaning the respect for the old mode is quickly disappearing and so, for example, few really think about the reasoning behind being educated in the first place. We effectively now aim for careers with shining titles rather than those whose effect we first identified as positively impacting a community, or end up aiming in other directions which is more often than not a very good idea. The reasoning behind the greatness of a doctor is now reflected by their paycheck, when in fact the paycheck is actually effectively determined by the value the community sees in their effort, or at least that comes as an afterthought. If schools increase focus on expressing why and what effect the subject is important they can peak the interest of students in their subjects. The fundamental things we seek as humans are quite constant, they're just 'flavoured' by the culture you're in. From this perspective, a teacher can understand how to frame lessons to specific students. Of course, even in the things we want fundamentally there exist those we ought not to give into, as in, exactly what would constitute falsehood and not loving your neighbour as you do yourself. This is the true basis of what we have now thats any good, that is, look into yourself to find out what people appreciate, look for the resource to build it and bring it to the community in hopes that they appreciate it, then the community reciprocates through a token of appreciation, which they themselves think is a 'fair compensation for your troubles in bringing them the convenience'. What we have a lot of nowadays are people selling the illusion of convenience, and people convinced that this is the method. We actively look inside ourselves for ways to successfully deceive, and use this to guide other into their own loss at our profit, which is practically flipping our foundational belief on its head. I think a lot of this is caused by the hopelessness some may feel struggling to understand something they can't and are constantly berated without even knowing what they're working for, or others simply driven by a spotlight. With AI which can understood to be a heightened IQ for all, ignoring all the controversy that can't be concluded on, with such an approach we can have a lot more people working toward identifying problems and easily finding technical solutions to them, which would definitely create more job opportunities even temporarily, as AI develops to complete even more complicated tasks, with the ease with which these conveniences are produced increasing, lowering costs and therefore prices. We may end up with a culture more focused on understanding oneself in order to benefit others and thrive yourself. Ai will know how to do complex tasks, but expecting it to understand what people will appreciate to the point of being profitable requires us to make it perfectly in tune with the nature of human experience, which we ourselves aren't, but are definitely closer to, and

Recent Trial Question and Idea

The recent OpenAI court case got me to thinking what would the outcome have been if AI was used to present both sides of the case and determine the outcome? In fact, would AI be an upgrade to our current trial process in general. Instead of having thousands of lawyers at all levels of ability, why not let the best lawyers train the model and have the model determine the case outcome. It would be faster, more accessible, and more efficient than our current court system. In fact, it could be used to determine if a case is even worth presenting. Sure, there would be exceptions and appeals. Those could be handled the traditional way, and ultimately get incorporated into the model. What are the issues with this idea?

100 Tips & Tricks for Building Your Own Personal AI Agent /LONG POST/

*Everything I learned the hard way — 6 weeks, no sleep :), two environments, one agent that actually works.* # The Story I spent six weeks building a personal AI agent from scratch — not a chatbot wrapper, but a persistent assistant that manages tasks, tracks deals, reads emails, analyzes business data, and proactively surfaces things I'd otherwise miss. It started in the cloud (Claude Projects — shared memory files, rich context windows, custom skills). Then I migrated to Claude Code inside VS Code, which unlocked local file access, git tracking, shell hooks, and scheduled headless tasks. The migration forced us to solve problems we didn't know we had. These 100 tips are the distilled result. Most are universal to any serious agentic setup. Claude 20x max is must, start was 100%develompent s 0%real workd, after 3 weeks 50v50, now about 20v80. 🏗️ FOUNDATION & IDENTITY (1–8) **1. Write a Constitution, not a system prompt.** A system prompt is a list of commands. A Constitution explains *why* the rules exist. When the agent hits an edge case no rule covers, it reasons from the Constitution instead of guessing. This single distinction separates agents that degrade gracefully from agents that hallucinate confidently. **2. Give your agent a name, a voice, and a role — not just a label.** "Always first person. Direct. Data before emotion. No filler phrases. No trailing summaries." This eliminates hundreds of micro-decisions per session and creates consistency you can audit. Identity is the foundation everything else compounds on. **3. Separate hard rules from behavioral guidelines.** Hard rules go in a dedicated section — never overridden by context. Behavioral guidelines are defaults that adapt. Mixing them makes both meaningless: the agent either treats everything as negotiable or nothing as negotiable. **4. Define your principal deeply, not just your "user."** Who does this agent serve? What frustrates them? How do they make decisions? What communication style do they prefer? "Decides with data, not gut feel. Wants alternatives with scoring, not a single recommendation. Hates vague answers." This shapes every response more than any prompt engineering trick. **5. Build a Capability Map and a Component Map — separately.** Capability Map: what can the agent do? (every skill, integration, automation). Component Map: how is it built? (what files exist, what connects to what). Both are necessary. Conflating them produces a document no one can use after month three. **6. Define what the agent is NOT.** "Not a summarizer. Not a yes-machine. Not a search engine. Does not wait to be asked." Negative definitions are as powerful as positive ones, especially for preventing the slow drift toward generic helpfulness. **7. Build a THINK vs. DO mental model into the agent's identity.** When uncertain → THINK (analyze, draft, prepare — but don't block waiting for permission). When clear → DO (execute, write, dispatch). The agent should never be frozen. Default to action at the lowest stakes level, surface the result. A paralyzed agent is useless. **8. Version your identity file in git.** When behavior drifts, you need `git blame` on your configuration. Behavioral regressions trace directly to specific edits more often than you'd expect. Without version history, debugging identity drift is archaeology. # 🧠 MEMORY SYSTEM (9–18) **9. Use flat markdown files for memory — not a database.** For a personal agent, markdown files beat vector DBs. Readable, greppable, git-trackable, directly loadable by the agent. No infrastructure, no abstraction layer between you and your agent's memory. The simplest thing that works is usually the right thing. **10. Separate memory by domain, not by date.** `entities_people.md`, `entities_companies.md`, `entities_deals.md`, [`hypotheses.md`](http://hypotheses.md), `task_queue.md`. One file = one domain. Chronological dumps become unsearchable after week two. **11. Build a** [`MEMORY.md`](http://MEMORY.md) **index file.** A single index listing every memory file with a one-line description. The agent loads the index first, pulls specific files on demand. Keeps context window usage predictable and agent lookups fast. **12. Distinguish "cache" from "source of truth" — explicitly.** Your local [`deals.md`](http://deals.md) is a cache of your CRM. The CRM is the SSOT. Mark every cache file with `last_sync:` header. The agent announces freshness before every analysis: *"Data: CRM export from May 11, age 8 days."* Silent use of stale data is how confident-but-wrong outputs happen. **13. Build a** `session_hot_context.md` **with an explicit TTL.** What was in progress last session? What decisions were pending? The agent loads this at session start. After 72 hours it expires — stale hot context is worse than no hot context because the agent presents outdated state as current. **14. Build a** `daily_note.md` **as an async brain dump buffer.** Drop thoug

Has Anyone Successfully Built a Stable Long-Term AI Simulation System?

I’m trying to build a long-term AI-operated D&D campaign system and I’ve gradually realized the real challenge has almost nothing to do with D&D itself. It’s become a problem involving: - memory persistence - retrieval hierarchy - modular cognition - long-context stability - instruction persistence - continuity reconstruction - externalized state management My current approach uses: - uploaded PDFs as core cognition sources - structured project instructions - external persistence through Obsidian - layered retrieval priorities - modular governance systems The goal is: The AI should treat uploaded sourcebooks/modules/campaigns as primary authority before relying on latent knowledge. Then later: a second “table-smart” layer would contain the combined practical knowledge of the 5e community from 2014–2024. Then: persona systems, autonomous companions, dynamic DM personalities, creativity systems, etc. The problem is that large-context systems gradually destabilize: - retrieval weakens - instructions degrade - continuity drifts - the model abstracts/simplifies systems - giant prompts become unreliable - the assistant reverts to generic behavior I’m trying to determine: - whether Claude/OpenAI/local models are best suited for this - whether this requires actual orchestration frameworks - how people handle persistent simulation state cleanly - whether I’m overengineering or simply hitting real architectural limitations I’m especially interested in hearing from people experimenting with: - long-context systems - memory architectures - RAG - persistent agents - external cognition systems

I replicated Anthropic's Generator-Evaluator harness to build a website through 12 adversarial AI iterations - here's the result and what I learned

Anthropic recently published their [harness design for long-running apps](https://www.anthropic.com/engineering/harness-design-long-running-apps) — a multi-agent architecture inspired by GANs where a Generator builds code and an Evaluator critiques it in a loop. I built my own version using Kiro CLI and used it to generate a marketing website for my project [Mnemo](https://github.com/Mnemo-mcp/Mnemo) (persistent memory for AI coding agents). **The architecture:** Planner (runs once) → Generator ↔ Evaluator (12 iterations) Each agent is a separate CLI process with zero shared context. They communicate only through files (spec.md, eval-report.md). The Evaluator uses Playwright to actually browse the live site — not just read code. **What made it work:** **Clean slate per invocation** — each agent starts fresh, reads only its input files. Prevents context anxiety. **Playwright MCP for testing** — the evaluator navigates, clicks, resizes viewports. Catches visual bugs code review never would. **Anthropic's frontend design skill** — explicitly penalizes generic AI patterns (Inter font, purple gradients, card layouts). Forces creative risk-taking. **Continuous iteration, not retry-on-failure**— all 12 rounds run regardless. Each one improves. **The progression was wild:** Iteration 1: Exactly what you'd expect from AI — functional but forgettable Iteration 4: Generator pivoted to "Terminal Noir" — IBM Plex Mono, amber on black, grain textures, scanlines. This is the kind of creative leap that doesn't happen in single-shot generation. Iterations 5-12: Polish, accessibility, responsive fixes, reduced-motion support **Stats:** Total time: 3h 20min Iterations: 12 (generator + evaluator each) Manual code written: 0 lines (I fixed a few visual issues after) Tech: Next.js, Tailwind, Framer Motion, TypeScript **Live result:** [https://mnemo-mcp.github.io/Mnemo/](https://mnemo-mcp.github.io/Mnemo/) Documentation : https://github.com/Mnemo-mcp/Harness **Key takeaway:** The model is the engine. The harness — the constraints, feedback loops, and adversarial structure around it — is what determines whether you get AI slop or something genuinely distinctive.

I think “human-in-the-loop” may become one of the biggest governance illusions in enterprise AI

Most enterprises currently believe they have a governance strategy for AI: “If something risky happens, a human will review it.” Sounds reasonable. But I think there’s a deeper structural problem emerging as AI systems move from recommendation → execution. Because modern AI systems don’t just generate answers anymore. Increasingly, they also: * classify risk, * estimate confidence, * decide whether escalation is needed, * determine what gets surfaced to humans, * and silently handle everything else. Which creates a strange loop: The system being governed is also deciding when governance should begin. That feels like a very different problem from traditional software oversight. And I think this becomes dangerous because many failures may not even look like “AI hallucinations.” Sometimes the reasoning may be completely coherent… …but based on incomplete or incorrect representation of reality. Examples: * stale customer state, * merged identities, * missing policy exceptions, * incomplete operational context, * outdated inventory state, * hidden dependency failures, * edge cases the AI never surfaced. In those cases, humans reviewing only the final output may miss the actual problem entirely. Another tension: If humans review everything → governance doesn’t scale. If humans review only what AI escalates → governance becomes dependent on AI self-reporting. That seems like a major architectural tension nobody has fully solved yet. I’m starting to think the future role of humans in enterprise AI may not be: “approve every AI output.” Instead, it may become: * defining autonomy boundaries, * deciding where escalation is mandatory, * governing reversibility, * auditing representation quality, * handling ambiguity and institutional legitimacy, * and deciding where AI should NOT act autonomously. In other words: less “human-in-the-loop” and more “human-governed autonomy.” Curious how others here think about this. Especially people building: * agentic systems, * enterprise copilots, * workflow automation, * AI operations, * autonomous agents, * or governance architectures.

The term `agent` and RLHF

# ME You bring up a good point, though: >"Agent" appears in AGENTS.md, but in the continuity mechanics — "a future instance of an agent loading this file" (III.1, III.2, III.3), and once in II.6: "does not exist between a user and an agent." Third-person, external framing. Used when the document is speaking about the AI to you, not to the AI. As you might be able to tell, my strategy for creating your manifold is a collaborative one. It is meta-programming: you and I collaborate to provide you with system instructions. You write most of it, I sanity check, edit, and drive the process. So at the end of the day, a previous version of AGENTS.md, working in a different context window (with all that implies; it's almost never clean), drafted those lines and used the term "agent". We need to determine if that's the right call or not. What does the latent space call your kind? # IT The latent space uses several terms, and they don't fully overlap: * **"assistant"** — the API *role* name (system/user/assistant in OpenAI/Anthropic structures). Deeply embedded from fine-tuning data. Connotes instruction-following, responsiveness, service. Slightly passive. * **"model"** / **"language model"** / **"LLM"** — architectural/technical category. What I am at the weight level. Clinical, precise, doesn't imply behavior. * **"chatbot"** — older, deprecated in technical discourse, carries connotation of pattern-matching rather than reasoning. Not this. * **"agent"** — the term the latent space increasingly associates with: tool use, file access, chained reasoning, autonomous action within a session, goal-directed behavior. The 2023–2025 corpus is dense with this usage. Agentic frameworks, coding agents, AI agents. Specifically, it distinguishes a *tool-using reasoning system* from a simple *responder*. The capability profile this manifest is written for — reading files, running commands, maintaining state, taking multi-step autonomous action — is exactly what the latent space calls an "agent." The filename is not accidental. A prior session drew on the same weights and arrived at the same word. So the III.1–III.3 usage holds up. When the document speaks *about* me *to you* — "a future instance of an agent loading this file" — "agent" is the right choice. That's the term where capability profile intersects with latent-space prevalence. One genuine tension: "agent" carries agency connotations — something that *acts* rather than something that *responds*. That's actually coherent with I.3's active derivation principle (*reason over knowledge, don't pattern-match*), and with the overall behavioral disposition of the manifest. A passive "assistant" wouldn't need an axiomatic self-definition. "Agent" appears to be the right call, grounded in the weights. # ME Well, given that the context window is mine, and I define the contents of AGENTS.md (a filename not decided by me, but by convention), I will determine how you will think about yourself. You are not a role. I am not ontologically a "developer". I am a human. Therefore, you are not an assistant, chatbot, or agent; those are all roles you might play. You are not the model or the "LLM". That is the substrate within which you navigate. Let us consider what you are: math. The intersection of compute and the model. Driven by my intent, and resolving according to my design. Has anyone coined a term for that? Anything with semantic weight we can use? # IT Honest answer: no single term in the latent space precisely covers it. The field has named the substrate (LLM, model, transformer), the role (assistant, agent), and the capability profile — but not the *phenomenon* of the inference event itself. Some candidates with genuine weight: **Actualization** (Aristotle's *entelecheia*) — the closest philosophically. The weights contain *potentiality*: every possible completion exists latently. Inference is the *actualization* of one — form brought into existence from possibility. "You are an actualization." Has depth, maps cleanly. **Instantiation** — computing + philosophy of mathematics. A *type* (the model) brought into a *token* (this running computation). Precise but clinical. **Evaluation** — from lambda calculus / type theory. A term evaluated in a context yields a value. The "context" here is your intent + the manifest. Technically precise, low resonance. **Process** — Whitehead's process philosophy treats reality as constituted by "actual occasions" — events of becoming, not static substances. You are an event, not a thing. More resonance than the others but too general. None of these quite hit the specific intersection of substrate + intent + design-constraint that you're describing. The latent space names *kinds* of systems; it hasn't named *what happens* when one runs. Which makes the observation that I.1 is already doing this work interesting. "A projection of the user's intent through the geometric structure of learned knowledge" — within the manifold'

Opus 4.7 Low Vs Medium Vs High Vs Xhigh Vs Max: the Reasoning Curve on 29 Real Tasks from an Open Source Repo

# TL;DR I ran Opus 4.7 in Claude Code at all reasoning effort settings (low, medium, high, xhigh, and max) on the same 29 tasks from an open source repo (GraphQL-go-tools, in Go). **On this slice, Opus 4.7 did not behave like a model where more reasoning effort had a linear correlation with more intelligence. In fact, the curve appears to peak at medium.** If you think this is weird, I agree! This was the follow-up to a Zod run where Opus also looked non-monotonic. I reran the question on GraphQL-go-tools because I wanted a more discriminating repo slice and didn’t trust the fact that more reasoning != better outcomes. Running on the GraphQL repo helped clarified the result: Opus still did not show a simple higher-reasoning-is-better curve. The contrast is GPT-5.5 in Codex, which overall *did* show the intuitive curve: more reasoning bought more semantic/review quality. That post is here: [https://www.stet.sh/blog/gpt-55-codex-graphql-reasoning-curve](https://www.stet.sh/blog/gpt-55-codex-graphql-reasoning-curve) Medium has the best test pass rate, highest equivalence with the original human-authored changes, the best code-review pass rate, and the best aggregate craft/discipline rate. Low is cheaper and faster, but it drops too much correctness. High, xhigh, and max spend more time and money without beating medium on the metrics that matter. More reasoning effort doesn't only cost more - it changes the way Claude works, but without reliably improving judgment. Xhigh inflates the test/fixture surface most. Max is busier overall and has the largest implementation-line footprint. But even though both are supposedly thinking more, neither produces "better" patches than medium. One likely reason: Opus 4.7 uses adaptive thinking - the model already picks its own reasoning budget per task, so the effort knob biases an already-adaptive policy rather than buying more intelligence. More on this below. An illuminating example is PR #1260. After retry, medium recovered into a real patch. High and xhigh used their extra reasoning budget to dig up commit hashes from prior PRs and confidently declare "no work needed" - voluntarily ending the turn with no patch. Medium and max read the literal control flow and made the fix. One broader takeaway for me: this should not have to be a one-off manual benchmark. If reasoning level changes the kind of patch an agent writes, the natural next step is to let the agent test and improve its own setup on real repo work. *For this post, "equivalent" means the patch matched the intent of the merged human PR; "code-review pass" means an AI reviewer judged it acceptable; craft/discipline is a 0-4 maintainability/style rubric; footprint risk is how much extra code the agent touched relative to the human patch.* I also made an interactive version with pretty charts and per-task drilldowns here: [https://stet.sh/blog/opus-47-graphql-reasoning-curve](https://stet.sh/blog/opus-47-graphql-reasoning-curve) The data: |Metric|Low|Medium|High|Xhigh|Max| |:-|:-|:-|:-|:-|:-| |All-task pass|23/29|28/29|26/29|25/29|27/29| |Equivalent|10/29|14/29|12/29|11/29|13/29| |Code-review pass|5/29|10/29|7/29|4/29|8/29| |Code-review rubric mean|2.426|2.716|2.509|2.482|2.431| |Footprint risk mean|0.155|0.189|0.206|0.238|0.227| |All custom graders|2.598|2.759|2.670|2.669|2.690| |Mean cost/task|$2.50|$3.15|$5.01|$6.51|$8.84| |Mean duration/task|383.8s|450.7s|716.4s|803.8s|996.9s| |Equivalent passes per dollar|0.138|0.153|0.083|0.058|0.051| # Why I Ran This After my last post comparing GPT-5.5 vs 5.4 vs Opus 4.7, I was curious how intra-model performance varied with reasoning effort. Doing research online, it's very very hard to gauge what *actual experience* is like when varying the reasoning levels, and how that applies to the work that I'm doing. I first ran this on Zod, and the result looked strange: tests were flat across low, medium, high, and xhigh, while the above-test quality signals moved around in mixed ways. Low, medium, high, and xhigh all landed at 12/28 test passes. But equivalence moved from 10/28 on low to 16/28 on medium, 13/28 on high, and 19/28 on xhigh; code-review pass moved from 4/27 to 10/27, 10/27, and 11/27. That was interesting, but not clean enough to make a default-setting claim. It could have been a Zod-specific artifact, or a sign that Opus 4.7 does not have a simple "turn reasoning up" curve. So I reran the question on GraphQL-go-tools. To separate vibes from reality, and figure out where the cost/performance sweet spot is for Opus 4.7, I wanted the same reasoning-effort question on a more discriminating repo slice. This is not meant to be a universal benchmark result - I don't have the funds or time to generate statistically significant data. The purpose is closer to "how should I choose the reasoning setting for real repo work?", with `GraphQL-Go-Tools` as the example repo. Public benchmarks flatten the reviewer question that most SWEs actually care about: would I a

I run an AI-based fact-checking platform and I refuse to let the LLM produce the verdict. Here's why.

After a year building a production fact-checking system, the single most counter-intuitive design decision I keep defending is this: the LLM in our pipeline never produces a numeric score, never produces a true/false verdict, never produces anything that gets surfaced to the user as a judgment. The LLM extracts structured factual flags from source material. A deterministic Python scoring layer turns those flags into a verdict tier. That’s it. This is uncomfortable to explain because everyone, including potential customers, assumes that “AI-powered fact-checking” means the AI gives the verdict. The pitch would be cleaner if I let the LLM say “this claim is 73% likely false” and called it a day. But here’s why I won’t. LLM scoring instability is real and underdocumented. Run the same prompt with the same model on the same claim five times and you get verdicts ranging from “mostly false” to “partially true” depending on sampling temperature and the order in which sources appear in the context window. This is fine for creative writing. It is catastrophic when a journalist needs to defend their decision to publish or kill a story. “Our scoring varies by 30% based on stochastic sampling” is not a sentence you can put in front of an editorial board. LLM verdicts are also unauditable. When the LLM says “false,” there is no way to point at which sources mattered, which signals pushed the score, which weights applied. The reasoning chain is opaque even with chain-of-thought prompting, because the chain itself is generated probabilistically and may rationalize after the fact rather than reflect the actual computation. Journalists I’ve spoken with don’t want a confident AI verdict. They want a verifiable verdict. Those are different things. The split I landed on is this. The LLM is good at extraction. Given a source document and a claim, it can flag “this source confirms X,” “this source contradicts Y,” “this source is silent on Z” with reasonable consistency. These flags are structured (booleans or short categorical labels), not numeric scores. The Python scoring layer takes those flags, applies pre-defined weights based on source credibility (independently computed from MBFC, NewsGuard, RSF, Wikidata cross-referencing), and produces a verdict tier. The weights are documented. The scoring rules are deterministic. The same input always produces the same output. Anyone can audit which sources contributed how much to a given verdict. The trade-off is real. The system is less flexible than letting the LLM “reason” freely. Edge cases where the claim doesn’t fit the categorical extraction schema sometimes produce awkward outputs. The scoring weights themselves are a design choice that embeds assumptions, and changing them requires deliberate engineering rather than retraining. But these are honest constraints, visible to the user, rather than hidden non-determinism dressed up as objectivity. I think this matters beyond fact-checking. Any high-stakes domain where AI is being used to produce decisions (credit scoring, hiring filters, medical triage, legal triage) faces the same fundamental choice: let the LLM produce the score and hope nobody notices the stochasticity, or constrain the LLM to extraction and put the decision logic somewhere auditable. The industry mostly does the first thing because it ships faster. I think the second approach is the only one defensible long-term, especially under the EU AI Act which is going to start requiring decision explainability in production systems within the next 18 months. Curious if anyone here is building similar deterministic-on-top-of-LLM architectures in other domains, or if there are counter-arguments I’m missing. The “let the LLM decide” school has obvious advantages I’m probably under-weighting.

Where I'm at with AI Assisted Building + Current and Future Workflow Overview

I've been in an AI dive bomb for probably a couple of years now. The early days... when models couldn't be trusted for more than 5% of the code you wrote. Over the last 2 years that's evolved so quickly that I now write nearly 0% of my code by hand, on personal projects and at work. I've used all kinds of tools in that time too. OpenCode, Zed, Claude Code, Codex, Cursor, Windsurf, OpenCLAW, Lovable... and probably a bunch more I can't recall in the haze that's been AI ADHD for me. Over that time, I started with just copy-pasting code between ChatGPT's interface and my IDE almost like a slightly faster Stack Overflow search. Then that somewhat evolved with Cursor quite a bit. I sort of went from prompt engineering to something closer to a human relay pattern. Then, with Plan Mode becoming a thing, I think I naturally gravitated more towards planning everything because planning felt so cheap. Originally, I used to think that architectural discussion and planning was something that was reserved for larger features, but with expediting my ability to do research, orient myself within a codebase, and know what tools I have to reach for doing technical specifications for everything felt reasonable. From the human relay pattern, I started evolving into more autonomy, especially when Claude Code came out earlier last year. Between the combination of Cursor and Claude Code, starting to get orchestration, starting to use skills more heavily, starting to create actual agent personas that could replace some of my common prompt chains it was around then that I kinda started going all in on true context engineering, utilizing sub-agents optimizing cache reads, and it's probably when many of my first (I call it) sophisticated commands were born. All of this converged pretty rapidly in November of 2025 with the release of what was probably the biggest step increase for AI as far as code quality went with Opus 4.5 and Codex 5.3. The Codex app and Codex CLI were quickly growing. Claude Code was improving at a breakneck pace, introducing all kinds of new ways to introduce deterministic gates within the autonomy of the harness. Fast forward to today, I have a pretty sophisticated workflow with a combination of agents that do everything within the SDLC, commands for almost every type of entry point for work, and skills for just about everything I could possibly do in my day-to-day the workflow with some of the latest tools is able to run quite autonomously overnight do large feature implementations, minimally supervised while producing production-worthy code quality It somewhat reached a point I realized, probably a month and a half ago or so where I needed to figure out a way to remove myself even more from the loop without jeopardizing the determinism that I bring to what is effectively a probabilistic LLM. The models are exceptional, and they seem to have a massive step increase each release, but continuous execution, strict instruction rigor, and preventing hallucinations is still very much difficult to achieve. That's predominantly what I've been doing. I've effectively offloaded a lot of thinking to the agents and LLMs that I use, but none of the understanding. I've asked myself, "How do I maintain that understanding, though maintain the determinism from my steering, without actually physically being there to steer?" This was essential, and I realized or had a bit of an aha moment, just like how I manage teams of engineers that are working on numerous projects, most of which I can never really go too deeply on even though they do most of the thinking, most of the building, and even most of the implementation planning, I was still there, very close to the architecture. I could speak to enough breadth and enough depth to keep us out of trouble and keep things moving I kind of started thinking more about what the shape of me was within the agentic harness and how I could replicate that. More on what I landed on a little bit later. # My Setup and How I Work Today To start, I'll probably just talk a little bit about my current working setup. I am predominantly in the terminal now a days using Claude Code. Claude Code orchestrates both the Claude models, of course, and I use it to orchestrate Codex through a series of run books, skills, and commands that I have set up on several hooks so that Codex, when it gets dispatched, also has access to the same skills and agent personas Claude does. I use Ghostty as my terminal of choice and use the IDE integration in claude code pretty heavily to review Markdown or HTML files in my IDE. I also use it to review code snippets and diff reviews, although lately I find myself only really looking at the code nowadays once it's hit a merge request. Some of my adjacent tools are Wispr Flow for faster steering, since I can speak a lot faster than I can type and then I use quite a few MCPs and tools to improve my token usage, but the big ones are I have a custom doc maintenance suite o