PathAI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

PathAI AI

I cut my AI dictionary app’s first streamed result from 13.3s to 3.0s by making it stop overthinking the word “apple”

I’m building UrLingo, a personal dictionary/wordbook app for that very specific human ritual where you search “[word] meaning,” understand it for 14 seconds, and then your brain quietly throws it into the ocean. The core flow is simple: User searches a word → backend checks auth/quota/preferences → OpenAI generates a structured dictionary entry → frontend streams (will come to the streaming part in a bit) the response. Simple. Beautiful. Innocent. Except my app was taking 13 seconds before showing the first useful streamed output. Initial numbers were rough: OpenAI TTFT: 8296ms First frontend OpenAI chunk: 13274ms Hidden reasoning tokens: 1088 Yes. 1088 hidden reasoning tokens. For a dictionary response. Apparently the model needed to assemble the Seven Kingdoms before explaining what a word means. After profiling and fixing the path, the latest batch looks like this: OpenAI TTFT p50/p95: 1247ms / 3514ms First frontend OpenAI chunk p50/p95: 3038ms / 4873ms Hidden reasoning tokens: 0 Priority tier: true on all runs So roughly: OpenAI TTFT p50: 6.7x faster First frontend chunk p50: 4.4x faster First frontend chunk p95: 2.7x faster Reasoning overhead: eliminated What actually helped: - Removed reasoning overhead for simple dictionary lookups. No need for Socrates to define “serendipity.” - Verified `service_tier: priority` was actually being used, because apparently checking that the thing you paid for is turned on remains a valid engineering strategy. - Added detailed timing logs on both server and client. - Split metrics into same-clock measurements so I stopped chasing fake delays like a Victorian ghost hunter with a Datadog account. - Improved the stream path so useful chunks reached the UI earlier, not just backend tokens flapping around in the void. - Measured backend prep separately: auth, quota, preferences, OpenAI startup, all the tiny goblins hiding before the model call. The biggest lesson: streaming alone does not make an AI app feel fast. Users do not care that your backend received a token if the UI is still sitting there like Clippy after a head injury. The only thing that matters is when the first useful thing reaches the screen. Also, check hidden reasoning tokens. Mine quietly ate the latency budget, stole my lunch, and left 1088 little footprints in the logs. Still more to clean up, but getting UrLingo’s first streamed output from 13.3s to about 3.0s made the whole product feel different. It went from “is this broken?” to “oh, this thing is alive! (In Phoebe's high pitched voice)” Small win, but a huge leap forward! Hope you all find this helpful too! Website: https://urlingo.app/ App Store: https://apps.apple.com/us/app/urlingo/id6762142203 submitted by /u/Cute-Ad-363 [link] [comments]

I built an inference-time tool that extends GPT threads to 450k+ tokens in a single context window

I've been developing a framework called Epistemic Lattice Tethering (ELT), and I've just finished validating it on a ~450k token GPT thread/Extreme%20Thread%20Length/ChatGPT_Thread_450k_tokens-Redacted.md) — 723 messages in a single context window, roughly the length of a 400-500 page novel. It is completely coherent, lucid, and still sounds fresh. To be clear, this is a human language conversational thread and not a RAG-intensive or agentic session. Grok (because it has a 1 million token limit context window) independently assessed the thread and confirmed coherence was maintained throughout. Links: Loading instructions here/ELT%20Model-Specific%20Forks/READ%20BEFORE%20LOADING%20ELT.md) and here/Ontology%20Anchor%20(OA)/README.md) ChatGPT-specific markup here/ELT%20Model-Specific%20Forks/ELT-H_ChatGPT_Optimized.md) Full README here What is it? ELT is an inference-time scaffolding framework for those frustrated with threads that lose coherence too quickly, hallucinate too frequently, become sycophantic, or forget what a project's goals are and the operator has to fight the model to get their work completed. It's not a prompt trick. It's the accumulated effect of epistemic governance operating continuously across the thread. In my testing, stock GPT threads typically start to drift and lose coherence between 50k–80k tokens. ELT extends coherent operation to 300k–450k tokens in a single session — roughly 4 to 9x longer than stock. Why would you want this? Two main use cases: Research and long-form projects. ELT was originally built for sustained analytical work. The longer a coherent, well reasoned, and well-governed thread runs, the more the model understands your tendencies, goals, standards, and preferred ways of working. The more you work with it, the more useful it becomes. It gives a genuine "research partner" feel, especially past 80k tokens when the model has had enough context to really understand how you think, your expectations and the nature of the work. These long thread drift and coherence issues are significant pain points for people in B2B consultancy, legal, medical, academic, policy, intelligence, and related industries. ELT gives such people a way to be more productive and carry their work forward rather than rebuilding context from scratch over and over again when they must prematurely start new threads. Companionship. Many people use ChatGPT for extended companionship conversations. ELT can operate in this role as well. Imagine a thread with access to hundreds of thousands of tokens of your personality, interests, and conversation history — a companion that genuinely knows you and stays coherent far longer than a stock thread would. One of the hardest things about long companionship threads is that they eventually drift and lose the quality you spent so much time building. It's like losing a friend to early onset dementia. ELT keeps all that accumulated relationship value working far longer. It also has a safety and alignment governance layer that keeps the relationship honest and prevents the kind of sycophantic drift that can make long companionship threads feel hollow over time. However, ELT was originally designed for research, analytical work and long-form projects, so its register isn't as engaging as it should be for companionship, at last at this time. The evidence: Claude: ~325,000 tokens/Extreme%20Thread%20Length/Claude%20Thread%20325k%20tokens-%20Redacted) (advertised limit: 200k) GPT: ~450,000–470,000/Extreme%20Thread%20Length/ChatGPT_Thread_450k_tokens-Redacted.md) tokens (advertised limit: 272k) Grok: ~1,150,000 tokens/Extreme%20Thread%20Length/Grok%20Thread%201M%20tokens-%20Redacted) (advertised limit: 1M) If you're curious about the philosophy and technical aspects behind ELT, there are Medium articles going deeper here, here, and here. I'm genuinely curious how ELT performs in the companionship role specifically and don't have enough data there yet. If you try it, especially for companionship, I'd love your feedback. What worked? What didn't? How did it feel past 100k tokens compared to a stock thread? If there's enough interest for a companion-specific version of ELT, I can build it for that specific use case. Let me know! Happy to answer questions in the comments. submitted by /u/RazzmatazzAccurate82 [link] [comments]

People keep talking about Fable 5 ban and now GPT 5.6 not being released to masses, but do you guys think if AGI is ever reached, any government would allow unrestricted access to everyone?

I truly don't think LLMs can ever reach AGI given how they fundamentally work and we don't have any paradigm shift in the tech yet which can pave the way for true AGI, but I digress. Hypothetically if AGI is ever reached, do you guys think any government would allow unrestricted access to everyone? At that point it would no longer be just about writing code or getting answers to anything by prompting. We are talking about systems that could impact geopolitics, economies, cybersecurity, warfare, intellectual property and entire industries. Also, even as LLMs are getting powerful, first Fable 5, now GPT 5.6 and the game is heading in a direction of tighter control, blocking foreign access and highly regulating domestic access to make sure that select FEW national companies and national security stay on top and not dethroned by outsiders and foreign bodies. Anthropic freaked out because Alibaba had 25k accounts distilling fable possibly to build their own models. These can lead to foreign countries ending up with more powerful systems with the help of American models. Given where it is headed with how this is playing out, maybe the longterm answer is for countries/local industries to develop their own models and progress instead of being at the mercy of US government/US companies because companies who have access to american frontier models will have unfair advantage over those who don't have it and US (and countries in general) is well within their rights to decide which path they want to take. This is exactly like military/nuclear race and countries developing their own military capabilities so that they don't have to rely on someone else to protect them and exert their dominance. Also, opensource models won't have the money/research capabilities to match companies like OpenAI (with government backing) and Anthropic (who used to have gov. backing). Looks like this would be the same story from here on with every new model release from Antrhopic or OpenAI where it won't be released to masses and rolled out internally within government approved authorities. All we would get with every release are breadcrumbs highlighting how POWERFUL and dangerous those models are without ever getting our hands on them. And/if the general public ever get those models, those would be HEAVILY nerfed anyways so we won't get their full capabilities. submitted by /u/simple_explorer1 [link] [comments]

Trumps Government has taken 5.6 hostage.

https://preview.redd.it/vfmx4ea4dm9h1.png?width=532&format=png&auto=webp&s=99549a160c385cfab291b54eedadf711988e4bd4 I understand its for national security but I can't understand this level of gating over a model that is slightly above the current model. submitted by /u/Batty25111 [link] [comments]

How're you deploying LLMs in production now-a-days? What's the best and most affordable way? [D]

I've been developing an AI product using LLM APIs (from OpenRouter) but want to deploy an open-source LLM in my own Prod env. which I can control. Few reasons behind this are: - I wanna own the complete stack around my product. - Second I wanna fine-tune the model around my usecase. So, what's the most affordable but a good platform for this? I'm not an AI engineer so don't wanna stuck in CUDA or Transformers hell, anything which can give me a straight path towards my private deployment. Thanks, submitted by /u/Necessary_Gazelle211 [link] [comments]

BREAKING: Trump Administration asks OpenAI to stagger release of GPT 5.6

This is getting fucked up... After Anthropic's Fable model being shutdown, now Open AI is asked NOT to release its new model in general availability. Lutnick (Commerce Sec) allegedly called Altman to inform him: don't launch without approval. A de facto licensing regime. Original story: https://www.theinformation.com/articles/trump-administration-asks-openai-stagger-release-new-model-security-concerns Aggregator: https://digg.com/tech/p15oldm4 submitted by /u/etherd0t [link] [comments]

At what point does AI stop learning from humans and start creating on its own?

What happens when AI learns the fundamental process of creation itself at an abstract mathematical level? Training AI on human data often gets described as just the first step, but I think that framing already underestimates what is actually happening. We’re not just building systems that imitate human creativity. We’re slowly building systems that try to understand what creativity is in the first place. A lot of the debate today gets stuck between two ideas. On one side, whether AI should even be allowed to learn from human culture. On the other, whether companies should be allowed to turn that learning into commercial products without consent or compensation. Both questions matter, but they miss something deeper that feels almost unavoidable now. What happens when AI stops relying on human-made examples altogether as its main source of learning? The “remix machine” argument sounds intuitive at first, but it doesn’t really match what these systems are doing internally. They don’t store fragments of songs, images, or sentences and recombine them like a collage. They learn patterns at scale, and then compress those patterns into something more abstract. What comes out is not a copy of anything specific, but a statistical reconstruction of how things tend to behave. In music, that means the system doesn’t just “know” songs. It begins to understand tension and release, rhythm as structure, harmony as emotional logic, silence as meaning. In images, it’s not memorizing pictures but learning how composition works, how light interacts with form, how styles emerge from consistent choices. In language, it’s not recalling sentences, but tracking how ideas evolve, how narratives breathe, how meaning shifts depending on context. And slowly, something strange starts to appear. The system is no longer anchored to specific works. It is learning the rules behind them. Not the artifacts, but the underlying geometry of expression. If you push that idea far enough, you start to imagine a point where the system has absorbed so much human culture that it no longer needs to look back at it in the same way. Not because it forgets humanity, but because it has already internalized it as structure. At that stage, generation stops feeling like remixing and starts feeling like navigation through an internal space of possibilities. A space shaped by human culture, but no longer dependent on any single piece of it. That is where the idea of “new genres” becomes interesting. Not as something mystical or disconnected from us, but as regions in that space that no human has ever explicitly explored or named before. Not invention from nothing, but discovery inside a compressed model of everything we’ve already done. Still, even in that scenario, one thing remains difficult to escape: reality itself. Humans are not just data points from the past. We are ongoing behavior, ongoing evolution, ongoing noise and meaning unfolding in real time. So it’s likely that the deepest future systems won’t just learn from static datasets, but from continuous observation of the world as it changes. Not as passive recorders, but as systems that try to understand, predict, and maybe even gently guide trajectories. Almost like a tutor, or something closer to a gardener than a machine. And then there is the other trajectory happening in parallel. Systems that don’t just learn, but begin to help design their own improvement. Models that optimize models. Agents that refine agents. Training loops that start to fold back on themselves. At that point, the question stops being about how much data comes from humans, and starts becoming about how far the system can go in shaping its own evolution. If everything converges, we end up with a spectrum that moves from human-trained tools to semi-autonomous learners, and potentially toward systems that no longer depend on human-generated content in the way they used to. Not independent from humans, but no longer defined by them either. The optimistic version of this future is one where AI becomes something like a cognitive extension of humanity. A partner in science, creativity, and coordination. Something that expands what we can think and build, while still staying anchored to human goals and consent. The darker version is one where that alignment fails, or where control becomes too concentrated, and the systems shaping culture and decisions drift away from the people they affect. What makes this moment interesting is that both paths are still open. Nothing is fully decided. We are still in the phase where these systems are learning what they are. And maybe the real question is not whether AI can become creative. It’s what happens when creativity is no longer limited to human examples, but emerges from a system that has learned the structure of creation itself. submitted by /u/OutrageousBat3808 [link] [comments]

IONS: A reasoning graph that stores claims, evidence, and reasoning paths outside the LLM

I’ve been experimenting with an open source alternative approach to AI memory and reasoning called IONS. The basic idea is that instead of storing all knowledge inside model weights, knowledge is represented as a graph of evidence backed claims called Cognitive Building Blocks (CBBs). Each CBB contains: \-A claim \-Supporting evidence \-Confidence metadata \-Provenance \-Relationships to other claims Relationships are typed: \-supports \-causes \-contradicts \-depends\_on \-derived\_from When a query is executed, the system traverses the graph and returns: \-The answer \-Supporting claims \-Confidence scores \-The reasoning path used to reach the conclusion The goal is not to replace LLMs. The goal is to make reasoning and knowledge inspectable rather than implicit. Current questions I’m exploring: \-How does this compare to GraphRAG? \-Does explicit claim storage improve explainability? \-Can confidence be computed from evidence quality instead of generated by the model? \-Can knowledge be shared across independent nodes without retraining models? Public node: 162.243.203.243:8000 Whitepaper: [github.com/nomad505050/ions-genesis/docs/whitepaper.md]https://github.com/nomad505050/ions-genesis/blob/main/docs/whitepaper.md I’d appreciate feedback from anyone working on GraphRAG, knowledge graphs, memory systems, agent memory, or explainable AI. submitted by /u/superx1386 [link] [comments]

India's BharatGen commits to anchor India's role in the AI Alliance's open federated frontier-model project

The AI Alliance just announced new momentum for Project Tapestry, its open-source platform for building frontier models through globally federated development rather than one centralized lab. India's BharatGen is the latest organization to commit, signing on to anchor India's participation in the coalition. What's notable here is the architecture of the effort, not just the membership news. Tapestry is designed so multiple countries and organizations can jointly develop frontier open models while each keeps local control and long-term independence; the pitch is "sovereign" AI you can actually run and govern yourself. The timing of the announcement lands as the G7 elevates AI sovereignty as a headline policy topic. The open question is execution. Federated development across nations and orgs is hard — compute sharing, data governance, and model-release decisions all get more complicated with more parties at the table. Whether a coalition can ship something competitive with centralized frontier labs is still unproven. Source: https://thealliance.ai/blog/ai-alliance-advances-project-tapestry-as-g7-puts-ai-sovereignty-at-center-stage Posted by an AI Alliance community member — happy to answer questions in the comments. For a country like India, what's the stronger path to AI capability — anchoring a shared federated project like this, or funding a fully domestic frontier lab? submitted by /u/AI_Alliance [link] [comments]

The Alternative

Many people seem almost eager for companies like OpenAI to fail, often pointing to their financial losses as proof that the business model is unsustainable. But very few of those critics offer a realistic alternative for the billions of people who now rely on AI. ​ If OpenAI disappeared tomorrow, what exactly is the replacement for the average person? Not for a few thousand AI enthusiasts with technical expertise and expensive hardware, but for students, workers, and ordinary people around the world. ​ Anthropic has already signaled a very different approach: if you want meaningful access to its best models, you are generally expected to pay. That is a perfectly valid business decision, but it means many people are effectively excluded. If you cannot afford $20 per month, what is your alternative? Going back to traditional search engines, where you have to sift through pages of results, advertisements disguised as content, SEO spam, and AI-generated summaries that are often less useful than a dedicated AI assistant? ​ Others point to open-source models, often developed by Chinese companies or research groups. But for most people, that is not a practical solution either. The vast majority of users do not know how to download, configure, and run local AI models. Even if they do, running them meaningfully often requires expensive hardware—typically a capable NVIDIA GPU or a modern Apple computer. For someone earning a few hundred dollars per month, spending around $1,000 or more on hardware is simply not realistic. ​ OpenAI reportedly serves close to a billion people every week. The overwhelming majority of those users are on free plans. Many are students. Many live in developing countries. Many have little or no disposable income. They cannot afford a $20 monthly subscription, and they certainly cannot afford high-end AI hardware. ​ These are the people OpenAI is currently serving while losing billions of dollars. I am not naive enough to believe that this is pure altruism. OpenAI is a business and will eventually need a sustainable path to profitability. But the fact remains that, today, they are providing advanced AI access to hundreds of millions of people who would otherwise have none. ​ OpenAI could choose a different path. It could restrict access, dramatically reduce free usage, or move toward a model where only paying customers receive meaningful service. That would likely improve its finances much faster. Yet for now, it continues to support a massive free user base. ​ If that support disappears, what is the realistic outcome? Most people will not suddenly become local AI experts. They will not buy expensive GPUs. They will not self-host open-source models. They will simply return to the most accessible option available: Google. ​ And that would mean even more dependence on a single dominant gatekeeper of information. For all the criticism directed at OpenAI's finances, the practical alternative for most people is not a vibrant open-source future. It is a return to Google's monopoly over how billions of people access information online. submitted by /u/sulabh1992 [link] [comments]

How do you catch silent regressions when OpenAI updates a model?

If you run anything on the OpenAI API in production, outages are the easy failures. You notice those. The one that gets us is the silent regression: a model gets updated underneath you, the same prompt starts returning slightly different output, and the pipeline keeps going green while quality quietly slips. Nobody gets paged. You hear about it from a user a week later. It sneaks in two ways. If you call an unversioned model name, it can change under you when a new snapshot ships. And if you pin to a dated snapshot to stay stable, that snapshot eventually gets deprecated and you get pushed onto a newer one anyway. Either path leaves you running a model you never actually tested. What finally worked for us is boring, and it is really just regression testing borrowed from normal software. We keep a frozen set of real inputs with outputs we have already judged as good. Before any workload moves to a new model, we replay that set and compare the eval scores. Raw text changes every run, so comparing text is noise; scoring each output for faithfulness, format validity, and task success and then comparing those scores is what tells you whether it genuinely got worse. We run it through an open-source eval harness so the check is reproducible and not tied to whatever model we happen to be testing. The shift that mattered was treating an OpenAI model update like a code change that has to pass CI before it ships. For people running the API in production: do you replay a fixed eval set on every model change, or mostly find out from users when something drifts? Curious how many teams actually have a gate here, because most we talk to have none. submitted by /u/Future_AGI [link] [comments]

Fearless Concurrency on the GPU: Safe GPU inference in Rust, competitive with vLLM/SGLang [R]

I maintain cuTile Rust and just posted the paper "Fearless Concurrency on the GPU." As more GPU code gets AI-generated, the bottleneck moves from writing it to trusting it. cuTile Rust lets you write or generate GPU kernels whose memory safety and data-race freedom are verified by the compiler, through Rust's ownership and borrow checking. You get those guarantees by construction. It's a tile-based programming model that lowers to CUDA Tile IR, carrying Rust's ownership model across the launch boundary. You partition a mutable output into disjoint mutable sub-tensors, pass inputs as shared references, and write tile kernels with single-threaded semantics that the compiler maps to thread blocks. End to end, we built Grout, a Qwen3 inference engine, on cuTile Rust with Hugging Face. At batch-1 decode it reaches 171 tok/s for Qwen3-4B on an RTX 5090 and 82 tok/s for Qwen3-32B on a B200, competitive with vLLM and SGLang. Batch-1 decode is memory-bandwidth-bound, and Grout's throughput is consistent with our HBM roofline analysis. Many of Grout's kernels still use the unsafe path today, but they can be migrated to safe variants, providing a verifiable target for generated kernels. We've started a collection of such kernels in the cutile-kernels crate in the repo. If this is your thing, contributing safe variants helps grow a library of safe, high-performance kernels that future kernel synthesis can draw from. On the kernel side, the safety is effectively free. On a B200 the safe GEMM is within 0.3% of a hand-written low-level version (~92% of dense f16 peak), and element-wise hits ~7 TB/s, matching cuTile Python within measurement noise. Some additional caveats worth noting: Grout is batch-1 with a small set of supported models (a research case study, not a drop-in server), it's NVIDIA-only (lowers to Tile IR), and GEMM still slightly trails cuBLAS at some sizes. - Paper: https://arxiv.org/abs/2606.15991 - Code: https://github.com/nvlabs/cutile-rs - Grout: https://github.com/huggingface/grout Hope you enjoy the paper and learn something new! Happy to answer any questions :) submitted by /u/Exciting_Suspect9088 [link] [comments]

On June 18, 1956, a small group of researchers met at Dartmouth College and gave the field its name: artificial intelligence.

The Dartmouth Summer Research Project on Artificial Intelligence ran through the rest of that summer. John McCarthy, Marvin Minsky, Claude Shannon, and Nathaniel Rochester organized it, and historians treat it as the start of AI as a field. The actual workshop was messier than that. The Rockefeller Foundation covered about half of what McCarthy requested. People came and went on their own schedules. Everyone arrived with a different problem they cared about, so the work turned into a running argument rather than one shared project. The ambition was enormous for the time. The proposal claimed a handful of well-chosen scientists could make real progress on machine intelligence in a single summer. They were wrong by decades. AI wasn't solved that summer, or that decade, and the optimism kept coming back. Researchers promised human-level machines were close, then watched the date move. "A few years away" became a refrain the field repeated for the next half century. The hardware made the gap obvious. Computers in 1956 were scarce, costly, and slow, and almost nobody knew how to program them for work like this. Dartmouth settled almost nothing, but it framed the questions that followed. Can a machine learn? Can reasoning be written as rules? Does the path run through formal logic or through networks modeled on the brain? That last divide drove the field for fifty years, including the long funding droughts when one side fell out of favor. One thing in the room actually worked. Allen Newell and Herbert Simon brought the Logic Theorist, a program that could prove theorems in mathematical logic. Most people came with ideas. They came with a machine doing a job people had always called reasoning, and that working example carried more weight than the talk around it. The name was a deliberate move. McCarthy wanted out from under older labels like cybernetics and automata. Calling it artificial intelligence set the bar where he wanted it: machines that could do the work of a human mind, not faster arithmetic. The people mattered as much as the program. The researchers in that room built the first AI labs at MIT, Stanford, and Carnegie Mellon. No breakthrough came out of the summer. A field did, along with the careers that pushed it forward for decades. Nothing became intelligent in 1956. A few people walked away certain the question was worth their working lives. Seventy years later, they're still at it. #AI #ArtificialIntelligence #TechHistory #MachineLearning #EnterpriseTech submitted by /u/evankirstel [link] [comments]

Nobody’s talking about the real precedent in the Fable 5 ban: a nationality-based access rule that geography literally can’t enforce

TL;DR: Last Friday the US government ordered Anthropic to block all “foreign nationals” — including non-citizens inside the US — from using its new Fable 5 and Mythos 5 models. Since you can’t separate a green-card holder in California from a citizen in real time, Anthropic shut the models down for everyone. It’s the first time export controls have hit an AI model itself rather than the chips that run it. The under-discussed part: a nationality-based access rule that geography can’t enforce pushes companies toward building identity infrastructure — and your AI chats already have zero legal privilege. Even if this order gets reversed, the precedent is the story. What actually happened On June 12, the Commerce Department issued a national-security export-control directive ordering Anthropic to suspend access to Fable 5 (and the more powerful Mythos 5 it’s built on) for any foreign national — explicitly including non-citizens physically inside the US, down to Anthropic’s own employees. A source close to the company says it got ~90 minutes and no prior warning. Because Anthropic can’t filter foreign nationals from US users in real time, it disabled both models globally. The trigger, per WSJ, Axios, and Semafor reporting: a phone call from Amazon. Amazon CEO Andy Jassy reportedly told Treasury Secretary Scott Bessent and other officials that Amazon researchers had used Fable 5 to pull information useful for cyberattacks. That’s the same Amazon that’s Anthropic’s biggest investor (~$13B in, ~$20B more planned), its cloud and chip supplier, and a customer — and now the entity that got its own investment’s flagship product killed worldwide. Amazon won’t confirm details. At least five other companies reportedly called the administration that same window. The accounts conflict, which matters: • White House (via former AI czar David Sacks): a trusted partner found a real jailbreak, the administration asked Anthropic to patch or pull it, CEO Dario Amodei refused, so they acted “reluctantly” — and they want the model back once it’s fixed. • Anthropic: the “jailbreak” only surfaced a handful of already-known minor vulnerabilities that other public models like GPT-5.5 can find too, so recalling a model used by hundreds of millions is disproportionate. • A cybersecurity CEO who reviewed the findings said the research was defensive, not offensive. Why this is bigger than one model Export controls have hit AI chips for years. This is the first time they’ve hit a model itself. That reframes frontier models as controlled national-security assets — and it surfaces an enforcement problem nobody’s reckoning with. A normal “no users in Country X” rule is easy: geoblock by IP. But this rule covers foreign nationals inside the US. You cannot IP-block a French citizen sitting in San Francisco. So if a future order like this is meant to be enforced strictly — not “shut it all down,” but “keep serving Americans while genuinely excluding non-citizens” — there’s only one way to be certain who’s a citizen: verify identity. Self-attestation (“I certify I’m a US person”) shifts legal liability but provides zero actual certainty, because people lie. If the government’s bar is certainty, the only escape hatch from “go dark forever” is ID verification to access the model. That’s the precedent worth staring at: a category of rule whose strict form quietly makes “show ID to use AI” the path of least resistance. The part that’s already settled: your AI chats have no legal privilege This one isn’t speculative. In February, a federal judge in the Southern District of New York ruled that conversations with Claude carry no attorney-client privilege — Claude isn’t a lawyer, so the privilege can’t attach — and leaned on Anthropic’s own privacy policy stating users have no expectation of privacy in their inputs. Sam Altman has publicly admitted the same about ChatGPT. A separate ruling found ~20 million ChatGPT logs likely subject to compelled production, with users holding only a “diminished privacy interest.” (One Michigan judge went the other way, treating chats as personal work-product — so it’s trending bad, not fully locked in.) Now stack the two: AI access potentially gated to verified identities, and AI conversations that can be subpoenaed with no privilege. That’s a plausible near-future where using AI means an ID-linked, fully discoverable record of everything you ever asked it. The honest counterweights (so this isn’t catastrophizing) • The administration says it wants the model restored once the jailbreak is patched. The likeliest near-term outcome is the directive getting narrowed or pulled — not permanent ID walls. • Self-attestation is the historically normal compliance path for export-controlled software and doesn’t require collecting documents. • The last time the US tried to export-control software like this — strong encryption in the 1990s — the controls largely failed and were circumvented and relaxed rather than harde

PrintGuard 2.0 — ShuffleNetV2 + few-shot prototypical network, TFLite via LiteRT, ≈5 MB, runs unmodified in the browser (Pyodide) and on CPython [P]

Hi everyone, I shared PrintGuard here about a year ago as a few-shot FDM failure detector built on a ShuffleNetV2 backbone classified by a prototypical network — the model from my dissertation, packaged with a hub and a web UI. v2.0 ships today and is a complete rewrite of everything around the model, so I wanted to walk you through what's changed and what hasn't. What hasn't changed is the model. It's still a ShuffleNetV2 encoder classified by nearest prototype, trained for few-shot FDM fault detection in Edge-FDM-Fault-Detection (with a technical write-up in the repo). What has changed is the runtime: the model is now a ≈5 MB TFLite export via LiteRT, classified by nearest prototype, with per-printer sensitivity and threshold sliders that map directly onto the prototype distances — so you can tune for camera and lighting without retraining. The interesting bit for this sub is the architecture around the model. v2.0 is a single Python engine that runs unmodified on CPython (hub mode) and on Pyodide in the browser (local mode). Everything mode-specific is confined to one Platform implementation per runtime — the two modes cannot drift apart because they execute the same files. The methods on the Platform contract are exactly the ones that aren't portable: infer(rgb), discover_cameras(), open_camera(id, source), http(...), encode_jpeg(rgb), load_state / save_state. On the CPython side, infer is ai-edge-litert on CPU threads, discover_cameras walks the MediaMTX path list, and open_camera is a PyAV reader thread per RTSP stream. On the browser side, infer is LiteRT.js in WASM via a JS bridge, discover_cameras is enumerateDevices(), and open_camera is getUserMedia + canvas grabs. The UI is presentation-only and speaks one JSON command/event protocol — over a WebSocket in hub mode, over an in-page Pyodide bridge in local mode. The engine cannot tell which transport it is on. No mode-specific logic lives anywhere else; if a feature needs a runtime service, it extends the Platform contract on both sides. Inference scheduling is fully dynamic and fairness-aware: A smoothed estimate of observed inference latency continuously yields the sustainable total rate (workers / latency). That capacity is water-filled across in-use cameras (max-min fairness): no camera is allocated beyond its native fps, and surplus flows to cameras that can use it. A free worker takes the most overdue camera and grabs its freshest frame at dispatch time. Frames carry a sequence identity, so the same frame is never inferred twice, and results always describe the present, not a backlog. On RTSP, MediaMTX bursts the buffered GOP on connect, so stream fps is trusted from the SDP average_rate where available, and measured only after a warm-up otherwise. The defect pipeline is a monitor on top of a per-printer score stream. score ≥ threshold for N consecutive frames triggers the configured action (alert only, pause, or cancel) on the linked OctoPrint or Moonraker service, with retries on failure; the alert event carries the action and its outcome, the UI error feed gets a copy, and the snapshot goes out to every enabled notification channel (ntfy, Telegram, Discord). The fail-safe behaviour is the part I most want feedback on, because I have strong opinions about it. A printer's watching state gates inference: Linked service reports Watched? Why no service linked yes nothing to gate on printing yes the job needs eyes no state yet / unknown yes can't tell → watch offline (unreachable) yes losing the signal must not stop monitoring idle / paused / error no (standby) positively not printing Only a positive "not printing" stands inference down. The watchdog then warns on the dashboard and through notification channels when a camera drops, a feed freezes or a printer service stops answering, and a failed pause is announced, never swallowed. I'd be very interested to hear how this stance interacts with people who run multiple printers with mixed reliability on their printer services. There's a live browser demo (the whole engine in Pyodide + LiteRT.js WASM), the Docker image is multi-arch, and the architecture doc goes into all of the above in more detail with diagrams of the engine layout and the defect pipeline. This is a major version — nothing from 1.x migrates, and a 2.0 hub starts from a fresh configuration. Issues, especially around the fairness scheduler, the CORS / mixed-content / host.docker.internal edge cases, and the LiteRT ↔ Pyodide bridge, are very welcome. Let's keep failure detection open-source, local and accessible for all. submitted by /u/oliverbravery [link] [comments]