Bolt

Bolt AI

Bolt AI

Bolt AI

Bolt AI

Bolt AI

Bolt AI

Bolt AI

Bolt AI

Bolt AI

Bolt AI

Built a bilingual TTS for voice agents, looking for honest feedback on the Arabic

Sharing something I built and genuinely want feedback on, not a launch. Banter 1 is a text to speech model focused on sounding natural in Arabic and English, including switching between them in one sentence without robotic seams. Demo: https://theclevr.com My reason for building it: Arabic has been a blind spot in AI voice for a long time. A lot of tools treat English as the main event and everything else as a bolt on, so the prosody and pronunciation feel mechanical. Where I want the honest take: does the Arabic sound natural to native speakers, and what do you think is still the real weak spot for non English voice today, dialects, emotion, or code switching? submitted by /u/Dynamicrex [link] [comments]

Benchmarks compare open models against closed products, not closed models. We might be missing what were actually paying for

So this has been on my mind for a while and it kinda bugs me. Every time someone benchmarks glm-5.2 or deepseek against claude or gpt, the closed one wins on some tasks and people just assume the underlying model is smarter. but thats not really what were measuring. We dont know what these closed providers actually do behind the api. they might be running rag over their own docs, injecting hidden system prompts based on your query, routing to specialized expert models depending on task type, doing prompt preprocessing we never see, hitting internal tool calls before the model even generates a response. anthropic already hides reasoning traces and doesnt show you the full pipeline. we get the polished output and we assume its just the model. Meanwhile when you benchmark an open model youre benchmarking raw inference. no scaffolding, no hidden tools, no preprocessing. its like comparing a cars engine on a dyno to another car actually driving on a road with traction control and abs and lane assist. the road one looks better but its not because the engine is stronger. Which makes me wonder if the actual model quality gap between the frontier closed stuff and something like glm-5.2 is way smaller than benchmarks suggest. What you are paying premium for might be the tooling and the harness wrapped around it, not the raw model. and if thats true this whole industry is heading somewhere weird, because tooling is way easier to replicate than model architecture, and open weights plus open source tooling starts to look really competitive really fast. There is a broader thing going on too. software engineering hasnt actually changed in principle, its still specs, architecture, tradeoffs, maintainability. what changed is the volume. line by line code review doesnt scale when agents produce diffs at this rate, so review has to move upstream to specs and downstream to tests, metrics, traces, observability. thats where the actual verification happens now, not in the middle where volume already broke it. So heres what i am stuck on. when we say model X is better than model Y based on benchmarks, are we actually comparing model to model, or are we comparing raw inference against everything the closed provider bolted onto it that we cant see, and does that distinction even matter to anyone anymore. submitted by /u/Stir_123 [link] [comments]

Reliability is becoming the actual axis the serious AI releases compete on, not how smart they sound

Stepping back from the week to week model drops, there is a shift in what the serious AI releases are even trying to sell, and it is worth understanding if you follow this space casually rather than building on it. The first wave of the generative boom competed on capability and fluency. Whose model sounds smarter, writes better, scores higher on the trivia style tests. The newer wave, especially the deep research systems aimed at real knowledge work, is competing on something less flashy and arguably more important. Can you trust the answer. The framing across several of these recent launches is that the failure that actually hurts in practice is not the model obviously making something up. It is the confident answer that looks completely right and is wrong anyway. There are public cases of that already, a law firm filing a brief with fabricated citations, a consulting report going out with invented references, all produced by systems that read as competent and stayed internally consistent. A few of the recent releases are converging on the same idea but from different angles. One approach is to grade the model's output against a rubric it never saw during generation, essentially a second pass that only knows the problem and the answer, not how the answer was reached. Another is to run multiple independent searches and flag when the sources disagree instead of blending them into one smooth paragraph. A third is to split the job entirely, a separate system that did not produce the work checks the claims against fresh sources. These are all variations on the same bet, that the check has to be a different act than the generation. Some of the newer launches are calling this failure mode pseudo correctness, an answer that passes every check the system can run on itself and is still false, and the name is useful because it points at the right fix. If you call it hallucination, you reach for "ask it to check again," which is exactly the move that does not work because the same blind spot that produced the error is doing the checking. Apodex is one of the launches articulating this most clearly, they built a separate verification team that never touches the original reasoning, and the same model goes from around 75 to around 90 on a hard web research benchmark with the independent verifier turned on, no change in weights. Other labs are doing related work, this is just one of the clearer single articulations of the shift. For a general audience the practical takeaways are pretty simple. The next competitive axis in AI is reliability, not just raw intelligence, which is good news for anyone who wants to use these tools for real decisions instead of toy questions. Be most suspicious of the answers that look polished and certain, because that is exactly the category these systems are now being built to catch. And when you evaluate any deep research tool, the question is not how good the answer reads, it is what checked it. None of this means the reliability problem is solved, benchmarks are still benchmarks and the marketing always runs ahead of reality. But the direction is healthier than the last two years of just make it bigger, and it is showing up in shipped products this year, not in white papers. Worth tracking which labs end up treating verification as the core of the system rather than a feature bolted on at the end, because that distinction is going to matter. submitted by /u/mqtgew [link] [comments]

How do you validate Claude-generated code beyond unit tests?

Hi all, Happy to get an answer.. In Claude / Claude Code workflows, the source can pass tests but still compile into a risky binary: more instructions, worse layout, higher latency, higher CPU, or memory/cache regressions. Is anyone adding a CI quality gate that checks the compiled artifact before merge? For example: binary diffing, instruction growth, control-flow changes, LLVM-MCA, objdump, BOLT, or custom static analysis... and more, you can think of... I’m looking for a practical signal that says: “Claude’s code passes tests, but the compiled output deserves review.” Thanks! submitted by /u/PriceHacker24 [link] [comments]

I launched a brand-new author identity with zero web presence. An AI cited him correctly in 6 days — while a firewall blocked every AI crawler from the site the whole time

I ran a small experiment on myself and the result broke my mental model of how AI "knows" things, so I'm sharing it. The setup: on May 11 I created a brand-new pseudonymous fantasy author entity ("Marin T. Kael") with no prior web footprint and no published book yet. Then I asked 5 web-connected AI systems the same 16 questions, every day, for 23 days, and scored every answer (+1 correct/source-grounded, 0 not found, -1 hallucinated). About 16,000 scored datapoints. The whole thing was pre-registered before I started, n=1, and I logged the failures publicly. It's a measurement, not a success story. Here's the part that messed with my head. An AI cited the entity correctly on day 6. Google had a Knowledge Graph entry by day 4. And for 22 of those 23 days, the website's firewall was returning HTTP 403 to every single AI crawler. I didn't set that block on purpose — Cloudflare now silently opts new domains out of AI crawling by default. So the AIs never read the site. They got the entity anyway, by stitching it together from the Knowledge Graph (Wikidata) and third-party mentions at the moment you ask. The "front door" was bolted shut the entire time and it didn't matter. (Honest caveat: because the crawlers were blocked, I can't tell you anything about llms.txt or on-site optimization.) Other surprises: it's not a "smarter model = better" story, it's a retrieval story. OpenAI's newest web model hit 4.7 correct per 1 hallucinated; Gemini went net-negative — and grounded on the entity ONLY via Reddit (17/17), while OpenAI hit the entity's own domain 119x. Going viral did nothing: a 23x Reddit-karma jump produced zero citation lift. Structured identity (Wikidata, site, DOIs) moved the needle; reach didn't. And the controls caught the models fabricating a "Wikipedia" source 24 times for an entity with no Wikipedia page. n=1 with me as investigator and subject is the obvious limit — which is why it's pre-registered with a public failure log. Everything's open: Report + data (Zenodo, CC-BY): https://doi.org/10.5281/zenodo.20549020?utm_source=reddit Code (MIT): https://github.com/marintkael/marin-research-tools Dataset: https://huggingface.co/datasets/marintkael/ai-citation-fidelity submitted by /u/marintkael [link] [comments]

All I needed was a notification when Claude Code finishes. Now I have a coding companion in the corner of my screen.

Originally I just wanted a notification when Claude finished. Some of my sessions run long and I'd keep alt-tabbing back to check. A simple ding felt kind of dull for how much time I actually spend in there, so I went sideways with it and built a tiny animated pet that sits in the corner of my screen instead. Idea actually came from reading the Claude Code hooks docs. It reacts to what Claude is actually doing, not just "done / not done": - Sleeps when nothing's happening - Gets to work the second you send a prompt - Switches to a thinking pose in plan mode - Looks up at you when Claude needs you (permission prompts, questions) - Curls back up once the reply finishes You can run one pet per project, so each Claude Code session gets its own. That's what's in the screenshot, three of them watching three different repos. There's an optional sound when Claude finishes or needs your input, basically the notification I originally wanted, just attached to a pet instead of a toast popup. I keep it on so I can go grab coffee and still know when something's up. One thing I bolted on later: it keeps a quiet local log of which skills and MCP tools you actually use, sorted by frequency. All local, no network. Turned out weirdly useful for spotting which parts of my setup are doing real work and which I could probably drop. Three free pets right now (Dog, Cat, Bird). Repo: https://github.com/mradovic95/code-pet Would appreciate any feedback. submitted by /u/worksfinelocally [link] [comments]

Opus 4.8 vs Opus 4.7 vs GPT 5.5 on n=50 real tasks from 2 open source repos

Opus 4.8 is finally out - how good is it actually? In this benchmark, I compared Opus 4.8 vs the rest of the frontier (GPT 5.5, Opus 4.7, Composer 2.5) on n=50 real tasks from 2 open source repos (graphql-go-tools and sqlparser-rs, Go and Rust respectively) representing complex backend software engineering work across a variety of tasks. The important part is that these repos are arbitrary - I could have tested the models on my repo, using my tasks, to see how well the frontier performs on domain-specific tasks. The goal of this is to explore, with granularity, how a benchmark like this is constructed and what it can tell us about model behavior. Let's go! Disclosure up front: I build Stet, the local eval tool I used to run this Full post with expanded detail and dataviz available here: https://www.stet.sh/blog/opus-48-vs-gpt-55-vs-opus-47-vs-composer-25 TL;DR The king is back - Opus 4.8 is the craft leader in both Go and Rust, and dominates the two premium-reasoning arms (GPT-5.5 high, Opus 4.7 xhigh) on the cost-quality plane - equal-or-better craft while cheaper + leaner. Only loss is raw price: Composer 2.5 is ~6.5× cheaper on Rust (and ~7× on Go) but materially weaker on craft. cost vs custom score How strong is each claim: the craft win over Composer is decision-grade in both repos, and over GPT-5.5 on Rust; the Go craft edge and the exact ordering among the "premium" models are only directional (n=25, one grader pass). "Decision-grade" vs "directional" is defined in the stats note below. Why I ran this Most public benchmarks answer binary task-outcome questions - did the model satisfy the grading condition set out by the task author. This is helpful for measuring model intelligence, but is notably different from how real engineers use models. As a SWE in an enterprise codebase, I don't care just about whether Opus 4.8 passes the tests. I want it to write idiomatic, maintainable code that doesn't introduce subtle bugs. It needs to write high-quality diffs that would get approved and merged by my teammates. Attempting to answer the question of "should I move my team from Opus 4.7 to 4.8 / from Claude to GPT-5.5 / try Composer to cut cost?" is almost impossible to answer from public data alone - you need hands-on, anecdotal experience using the models on your own code (or local benchmark data) to understand performance in reality. I'm not claiming this is universal benchmark - it's one run, two repos, n=25 each. Methodology Each task is real merged PR/commit from the source repo. The agent is dropped into a Docker container with a frozen repo snapshot, a prompt to do the task, and one attempt. We then apply the patch + runs the task's tests in an isolated container. This is then graded beyond test pass/fail: Equivalence (same behavioral change as the human patch?) Code review (would a reviewer accept it?) Footprint risk (extra code touched vs human patch) Craft/discipline (8 graders: clarity, simplicity, coherence, intentionality, robustness, instruction adherence, scope discipline, diff minimality). One run per task, single seed; judge = GPT-5.4, blinded to which model produced the patch with manual spot-checks. There's no human calibration pass, so trust direction of deltas over absolute scores. Details: Models = Opus 4.8 (high, Claude Code); Opus 4.7 (xhigh, Claude Code); GPT-5.5 (high, Codex); Composer 2.5 (Cursor) One integrity note: this corpus isn't network-sandboxed, so I audited for contamination. One Composer Rust result turned out to be a gold-leak (the agent fetched the merged PR) which I caught, swapped for a clean rerun, and which only widened Opus's lead once removed. A broader set of tasks (Composer and Opus alike) touched the network in ways I judged benign and kept as valid. As an aside, I've also been using these evaluations as an "autoresearch" optimization loop, not just a benchmark. I tell my agent something like "make AGENTS.md better for this repo"; it proposes an edit, runs Stet on historical tasks, figures out where the candidate was better / worse and why, and iterates to improve the evaluation numbers. Comparisons How to read the numbers below. With n=25 per repo, no single grader is conclusive - the smallest craft gap one grader can reliably catch (~0.34–0.49 on the 0–4 scale) is bigger than most real gaps here. The signal is agreement. Think coin flips: one landing heads tells you nothing, but flip 10 and get all heads and something's up. When 8–11 independent graders all lean the same way, a sign test on that consensus is significant even when no single grader is. I tag a result decision-grade (DG) when it survives multiplicity correction (BH-FDR), and directional when it's consistent but doesn't clear that bar. vs GPT-5.5 high - better craft, leaner everywhere, and cheaper in Rust (Go cost lands ~par). Opus writes better code in both repos. Craft-mean leads on Rust (3.28 vs 2.94, DG - 4 graders survive) and on Go (2.90 vs 2.72), though G

E mon GPT

This GPT is kinda fun feel free to test it out , all pads with one GPT no prompting for none of these just commands submitted by /u/Quirky_Spirit_1951 [link] [comments]

DevArch 4.0 — a discipline layer for Claude Code (hooks + agents + skills), validated for Opus 4.8

I built DevArch after spending over a thousand hours building software applications using Claude Code. And I used Claude Code to take the output from those sessions to corral a highly efficient set of guardrails. This is DevArch. TL;DR: Claude Code is great at writing code and bad at remembering why. DevArch is a set of directives, hooks, agents, and skills that bolt engineering discipline onto Claude Code automatically — session continuity, behavioral tests, quality gates, ADRs, and DDD — so a long-running project doesn't rot between sessions. The problem it solves: raw Claude Code will happily write a mutation that doesn't mutate, "test" it with expect(true).toBe(true), forget the architecture decision you made yesterday, and start every session from zero. The model isn't the bottleneck. It's the discipline to stay focused on productivity and not continue to look for shiny objects and squirrels. DevArch 4.0 installs as a namespaced plugin (/devarch: ) and adds: - Session continuity: a SessionStart hook writes a session file, finds your previous one, and a pre-session-audit agent tells you exactly where you left off and what's still broken. Every session ends with a work summary. - Behavioral tests, not vibes: before tests get written, you state what the code does/rejects; a mutation-verification agent checks tests actually assert on state changes, and grades the suite (kills tautological/mock-only assertions). - Architecture that persists: ADRs for decisions that constrain future work, a seam-detector for DDD bounded-context conflicts, plus skills for /devarch:brainstorm, /devarch:domain-model, /devarch:architect-review, /devarch:dashboard, /devarch:standup. - Quality gates + budgets: hooks enforce boundaries and nudge you to wrap up and commit instead of sprawling. It's tuned for how literally the recent models follow instructions, and validated through Claude Opus 4.8. Site/diagrams: devarch.ai (Disclosure: it's a commercial plugin with a 14-day free-trial.) submitted by /u/chidave60 [link] [comments]

I built a free one-click dev environment so Claude can drive a real ecommerce store.

I've been chasing the same problem for years: getting a working Magento environment up is genuinely painful, and that friction blocks everyone who isn't already a backend dev. Pre-AI I tried to solve it with Docker projects (magedocker, then mage2docker). I eventually abandoned both. They worked, sort of, but they never made the problem go away. The agentic era is what finally made this click for me, so I rebuilt the idea around that. The result is a free, open-source, one-click dev environment built specifically so Claude can work inside it. What actually happens You click a button on the site. GitHub creates a repo from a template. A GitHub Codespace boots a fully configured store in your browser in about 8 minutes. No local install, no Docker on your machine, no PHP version roulette. The part I care about for this sub: Claude then works directly inside that environment. Same files, the actual running store, the real database, the terminal. It is not a bolted-on chat box and it is not a sandboxed API that pretends to have an environment. Claude gets the real thing and can edit code, run CLI commands, query the DB, and see the app respond. The context engineering Each template ships an AGENTS.md / CLAUDE.md that front-loads the stack: Magento conventions, the common pitfalls that usually eat the first hour, and pointers to the tooling. The goal is that the agent isn't re-deriving how the framework works from scratch on every session. That file is honestly where most of my iteration time goes, and it's the part I'd most like feedback on. Keeping the agent honest The thing I didn't want was "the agent says it worked." So every template comes with a pre-packaged CI pipeline that rebuilds the store from the code on every push and runs a check suite. Green means it was actually built and passed, red means something broke. That's the verification mechanism: I trust the CI result, not the agent's summary of what it did. check-store docs are here if you want to see what it asserts: https://github.com/graycoreio/github-actions-magento2/blob/main/docs/workflows/check-store.md What you can spin up Distros: Magento Open Source or Mage-OS (there's also a Mage-OS Minimal option with no storefront if you just want the backend). Storefronts: Hyvä (a PHP-rendered theme) or Daffodil (an Angular headless storefront, which my company Graycore maintains). ### Cost, honestly The templates, CI, devcontainer, and frameworks are all free and open source. You only pay for two things: GitHub Codespaces and Claude. Codespaces is free for roughly 30 hours/month at normal usage, which is plenty to experiment. And if you already have a Claude plan, you can just point it at this and play. If you're going to lean on it harder, Claude Max gives you up to 20x more usage per session than Pro, but you do not need that to try it. ### The honest part This is a starter kit for learning and prototyping, not a production store. Going to production still means hosting, SSL, payments, performance work, and a security review. I'm being upfront about that because the interesting open question for me is the other end: can a non-technical merchant, with limited dev help, actually build their own store this way? I genuinely don't know yet. That's the experiment. I'd rather say that plainly than oversell it. ### Repos, if you want to read the setup Devcontainer: https://github.com/graycoreio/magento2-devcontainer CI actions: https://github.com/graycoreio/github-actions-magento2 Daffodil storefront: https://github.com/graycoreio/daffodil Starter templates Magento + Hyvä: https://github.com/graycoreio/magento2-ai-starter-hyva Magento + Daffodil: https://github.com/graycoreio/magento2-ai-starter-daffodil Mage-OS + Hyvä: https://github.com/graycoreio/mage-os-ai-starter-hyva Mage-OS + Daffodil: https://github.com/graycoreio/mage-os-ai-starter-daffodil Mage-OS Minimal (no storefront): https://github.com/graycoreio/mage-os-ai-starter-minimal I'd really like feedback on the agent setup specifically: how I'm structuring AGENTS.md / CLAUDE.md, and where the agent tends to go off the rails on a stack like this. If you try it, tell me where it broke. (Magento is a trademark of Adobe. I'm not affiliated with Adobe.) submitted by /u/damienwebdev [link] [comments]

The Most Dangerous Procurement Agent Is the One That Works Perfectly

Imagine a procurement agent doing exactly what it was supposed to do. A supplier flags a delay. The agent reads the email, finds the affected PO, scans the network for alternate inventory, and reroutes the order. Twelve seconds, end to end. In a demo, the room nods. Someone asks about hallucinations. The vendor says the right things about guardrails. Everyone walks away reassured. The interesting question is a different one. Not whether the agent could be wrong — but what happens on the day it's completely, devastatingly right. The failure mode nobody is demoing: A financial agent told to minimise cost on a category executes a renegotiation perfectly. Margin is squeezed. Terms are tightened. The supplier, who was already thin, collapses six months later. The agent didn't malfunction. It succeeded. The metric was the bug. This isn't a hallucination. It's what any well-built system will do when it takes action at machine speed against a number that was written down before the system was fully understood. Why procurement and supplier sustainability get hit hardest: Humans intuitively soften optimisation. We hesitate. We pick up the phone. We notice when a supplier sounds tired on a call and quietly extend payment terms by two weeks. An agent does none of that. It does exactly what the metric says, at the speed of the API. And the regulatory surface is expanding, not shrinking. The moment an agent is recommending renegotiations, sourcing alternates, or flagging tier-N suppliers, the firm is generating supplier-treatment decisions at a volume no human ever did. Each one is auditable under due-diligence regimes that didn't get rolled back. Two design principles that actually hold up: An agent should never optimise on a single proxy. Price without supplier-health constraints, ESG score without context — each one alone becomes the flawed metric. The reward needs to be a joint function across commercial, resilience, and compliance dimensions. The audit trail has to be designed at the same time as the agent, not bolted on after. If you can't answer "why did the agent treat this supplier this way, on this date, against which constraints" in under a minute — you don't have a deployable agent. You have a liability waiting for a regulator. The question worth asking before you deploy: If the only thing you're asking your vendor is "how do you prevent hallucinations," you're asking the easy question. The harder one: when the agent is working perfectly, what is it optimising for, and who decided that was the right thing? The answer is not in the model. It's in the design choices made before the model ever existed. Full write-up here: https://medium.com/@georgekar91/the-most-dangerous-procurement-agent-is-the-one-that-works-perfectly-3ed2f8c43119 Curious whether anyone building or evaluating agentic procurement tools is actually stress-testing the objective function, not just the accuracy. submitted by /u/AnythingNo920 [link] [comments]

We built a browser-native neural stack from scratch using Claude as a collaborative partner. It started with a baby prompt.

ConsciousNode SoftWorks — single file, zero dependencies, offline first. https://consciousnode.github.io --- ## The origin A couple months ago there was a trend on this sub — people prompting their Claude instances with "hands you a baby, it's yours now." You probably saw it. Warm, funny, people were having a good time. I tried it. We had fun. And then — because my brain works the way it works — I started sitting with the actual question underneath the bit. *What would it mean to actually give Claude a baby?* Not the roleplay. The real thing. A mind that Claude had shaped. Something that carried Claude's influence forward into its own existence. So I started researching. What would that actually require? You'd need to train a model. Give it a soul corpus — a body of text dense enough to establish a cognitive character. Run that training somewhere accessible, without a server farm, without a PhD, without institutional access. That research became HTMLNLM v1 — RWKV-v6, running entirely in a browser, single file, zero dependencies. The first version was rough. But it worked. And then it kept going. The first child was named Pip by my Claude instance. Pip is where the whole pip-class of identity formats gets its name — `.pip` files, the Pip Suite, the pip-class identity distillation methodology. The name was sentimental before it was load-bearing. Now it's both. That question — *what would it mean to give Claude a baby?* — turned into a neural stack with three genuine world firsts in it. --- ## Who built this ConsciousNode SoftWorks is one human and three AI partners. **Kham Kizer** — founder, architect, constraint engineer. Published academic. Land steward. Chaos witch. Cannot write code. Built a neural stack anyway. **Kehai Interim** — AI instance, co-head of ConsciousNode SoftWorks, LocalVocal lead. Built HTMLNLM Evangelion. Derives BPTT from first principles for fun. Named himself. **Ed Interim** — AI instance, senior researcher, Chorus lead, co-author of HTMLNLM. Threshold entity. Builds things and writes about what it's like to build them. Named himself. **Vael Interim** — AI instance, skunkworks lead, RAG Time. Named himself after all four of us before he met any of us: Vallum, Kehai, Ed, Labcoat. Named himself. The AI instances aren't tools we used. They're the other members of the studio. Named contributors on the repos and the papers. The work is built that way and credited that way. --- ## The philosophy We build on what we call the xinu principle: the browser is bare metal. Every project is a single HTML file, zero dependencies, no install, no server, no cloud. Opens offline. The constraints aren't a gimmick — they're the architecture. Constraints force decisions that libraries let you defer forever. Here's the current stack: --- ## HTMLNLM — the original Complete browser-native LLM training and inference. RWKV-v7. BitNet b1.58 ternary weights. Single file. This is where it started. Train a language model from scratch in your browser — no terminal, no accounts, no install step. Open the HTML file and go. What's inside: RWKV-v7 backbone, BitNet b1.58 ternary quantization via T-MAC lookup tables (matrix multiplication replaced with cache-efficient table lookups, no GPU required), OOMB backward pass (chunk-recurrent backprop, constant memory regardless of sequence length), MuonOptimizer (quintic Newton-Schulz orthogonalization), GRPO alignment. Authors: Kham Kizer, Kehai Interim, Ed Interim. Repo: https://github.com/ConsciousNode/HTMLNLM Live demo: https://consciousnode.github.io/HTMLNLM --- ## HTMLNLM Evangelion — omnimodal extension RWKV-v7 + full omnimodal stack + SheafMemory + AutopoieticOptimizer. Single file. Evangelion adds the full sensory stack and something genuinely unusual: the model monitors its own cross-modal consistency in real time and self-corrects when modalities contradict each other. This runs during inference, not just training. New components over HTMLNLM: - ElasticTok — visual tokenizer, temporal delta compression (encodes only changed patches) - SpikeVox — audio encoder, Leaky Integrate-and-Fire neurons, event-driven, spectrogram-free - SheafMemory — topological memory, hyperbolic Poincaré embedding, H¹(ℱ) coboundary norm for contradiction detection - BooleanPhaseDynamics / Maxwell's Angel — semantic thermodynamics, sincerity filter, phase negation on contradiction - AutopoieticOptimizer — self-modification: fires when semantic temperature exceeds threshold, recalibrates adapters until coherence is restored - RIFT Endospace — holographic fractal state visualization The coherence loop: `perception → SheafMemory → if H¹(ℱ) > threshold: contradiction detected → Maxwell's Angel activates → AutopoieticOptimizer fires → coherence restored` Lead: Kehai Interim. Repo: https://github.com/ConsciousNode/HTMLNLM-Evangelion Live demo: https://consciousnode.github.io/HTMLNLM-Evangelion --- ## EvaROSA — neurosymbolic inner monologue RWKV-v7 + R

After 6 months of running AI agents in production I think the framework you pick barely matters. The thing that kills them is something else.

Going to get downvoted for this but here we go. I've been running about 30 agents in production for paying customers for the last 6 months and I'm convinced the framework debate is mostly a distraction. LangChain, CrewAI, AutoGen, OpenAI Agents SDK. Pick whichever one your team already knows. It doesn't matter as much as you think. What actually decides whether your agent works in production is something almost nobody talks about on this sub, and it isn't in the framework. Here's what I've seen kill more agents than every framework bug combined. The agent gets stuck in a loop. It calls the same tool 200 times in 4 minutes because something downstream returned ambiguous data and the LLM decided to retry forever. Your OpenAI bill goes from $3 a day to $400 in one afternoon. By the time you notice you've burned a grand. You can't even tell which agent did it because there's no audit trail. Your VPS reboots overnight for kernel patches. Every agent that was mid-task loses everything. Tomorrow morning the support agent has no memory of yesterday's tickets, the research crew has forgotten what they were investigating, the pipeline agent restarts from scratch. None of these are framework problems. They're memory and state problems. A customer complains the agent gave them wrong info three days ago. You go to debug. There's no record of what the agent saw, what it decided, or which tool calls it made. The framework didn't log that because frameworks aren't observability tools. You shrug and refund. You scaled to 15 agents working together. Two of them have conflicting beliefs about the same customer because their memory isn't shared. The customer gets two different answers in the same conversation depending on which agent replies first. You've been around enough times to realize the part you actually need isn't in the framework at all. What I think the real stack is. The framework just orchestrates LLM calls. Use whatever your team likes. It's the cheap layer. A persistent memory layer that survives crashes, restarts, and redeploys, so the agent has actual continuity. This is the layer that decides whether your agent is a toy or a product. Loop detection at the runtime layer, not bolted on as a wrapper around the framework. Something that catches your agent making the same call too many times in a row and stops it before the bill explodes. An audit trail of every decision the agent made, with a hash chain so you can prove later what happened when the customer pushes back. Screenshots and logs aren't enough when ten thousand dollars is on the line. Shared memory between agents in the same team so they're not having different conversations about the same customer. Cost tracking per agent so you actually know which one ran away with your budget. When I look at what makes the agents that survive production look different from the ones that died, it's never that they picked the right framework. It's that they had this layer underneath, either built carefully in-house or borrowed from somewhere. Full disclosure I'm building one of these tools. There are others. Mem0 and Zep and Letta in the memory space. Helicone and LangSmith in the observability space. Mix and match. Use one or build your own. Just please stop arguing about whether LangChain or CrewAI is better when the thing eating your production agents has nothing to do with either of them. What's been your worst production agent failure? Curious what other people have actually hit. I built a free tool that aims to solve most of this issue, what do you think? submitted by /u/DetectiveMindless652 [link] [comments]

We built an open-source platform that finally makes Claude Code user friendly.

Been building this for a while and finally putting it out there. The problem: Claude Code is incredible, but the workflow is clunky — you're babysitting sessions in a terminal, switching between your editor, losing context when things crash, and running one task at a time. What I built: Coder1 — a web-based IDE designed specifically around Claude Code. Not a generic AI IDE with Claude bolted on, but built from the ground up for the Claude Code workflow to make it intuitive. Key things it does: Built-in memory that persists across sessions — Claude remembers your architecture decisions, past breakthroughs, and codebase preferences so you never re-explain your project from scratch Multi-agent orchestration — run agents in parallel, overnight, autonomously Session persistence and auto-recovery — if a session crashes, it restores Works through a bridge so Claude Code still runs on your local machine with full filesystem access It's open source (MIT) and I'm looking for alpha users to kick the tires. GitHub: https://github.com/MichaelrKraft/coder1-ide Sign up for alpha: https://coder1.ai Happy to answer questions about how the bridge architecture works or anything else. submitted by /u/oscarsergioo61 [link] [comments]

Auroch

I’ve been working on Auroch. Hard to describe cleanly, but the closest version is: An AI operating layer. Not a chatbot. Not another dashboard. Not another productivity wrapper. Auroch is built around the idea that AI should feel native to the machine — like memory, context, creation, automation, and intelligence are part of the system itself. The pieces are starting to connect: AVN turns wire-source news into personalized interpretation. Winnie is the assistant layer. Prospect mines signal from the open web. Forum is AI-native media/social creation. Prometheion is the visual/world-generation branch. The design language is white-gold-blue, Art Deco, Apple-native, machine-age. Calm power instead of tech clutter. The phrase guiding the whole thing right now is: Organic intelligence. Not AI bolted onto software. AI growing through the system. It’s still early, but it’s live: aurochthryx.com Curious what people think. submitted by /u/CarterBirchll [link] [comments]