ServiceNow AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ServiceNow AI AI

ChatGPT 5.6 Confusion

I was talking with my brother earlier today when he mentioned that he couldn’t find his ChatGPT icon anymore. At first, I thought he’d accidentally moved it or deleted it. Then I stared at the screen of my desktop and realized something was going on with ChatGPT. The application I have been using daily is now ChatGPT Classic. Sitting next to it was another ChatGPT icon that looked almost identical, except this one offered two choices at the top: Work and Codex. Neither of us knew what had changed, so we did what most curious users would do. We started clicking around. I’ve been using ChatGPT since 2024, and it has become my AI daily driver. I use it to research topics, brainstorm ideas, outline articles, and help with software projects. Like many long-time users, I’ve built up years of conversations and a workflow that fits my style. That is why I was perplexed about what was going on. The new application wasn’t difficult to figure out at first. It looked like the old Codex app, but it now had two modes. Work mode is for “getting work done”. Stuff like building a website, planning, creating briefs, and automating productivity tasks. Codex is targeted at software developers. As a result, I thought OpenAI had simply expanded ChatGPT rather than replacing it. Then, I noticed something that completely changed my understanding of the update. There is a chat option on the left side of the window that pops open a chat panel on the right. When I examined it, I saw what looked like my existing ChatGPT conversations. Naturally, I assumed they were connected to the same conversations I had been having in ChatGPT Classic because they had the same names. Then, I opened one of the recent conversations, added another message, and went on with what I was doing. After that, I switched back to ChatGPT Classic, expecting to continue the same discussion there, but I couldn’t find the new message anywhere. I was baffled. I realized I didn’t actually understand how the two applications were related. I spent the next hour trying to answer what seemed like a simple question. Was I looking at one conversation history or two? Were the applications sharing my chats, or was the new app keeping its own history? I clicked through menus, compared windows, and searched for some explanation, but nothing I found could answer those questions. I looked over the OpenAI documentation, and I couldn’t find answers there either. Eventually, I turned to Reddit, assuming someone else had already figured it out. Here is what I found: ChatGPT + Codex: What Redditors Are Saying (Summary) Merge Status & What Changed Unified App Announcement: Codex has now merged with ChatGPT. App Rename / Confusion: The old ChatGPT app was renamed “ChatGPT Classic”; users report confusion and missing chats/projects after updating. “Where are my projects, my custom GPTs, all of my chats? Not in this stupid little pop-out for ‘chats’ and the old app is now ‘ChatGPT Classic?’” Desktop Update Reports: Desktop builds updated (macOS 5.6), and some users saw icon/behavior changes that felt like a rename rather than functional changes. “The 5.6 build number is right there, but the jump from plain ChatGPT to Codex feels like a rename more than a feature drop.” Usage Limits & Billing Concerns Uncertainty About Shared Limits: Many posts debate whether ChatGPT and Codex usage quotas are merged; answers vary, and official clarity is lacking. “So chat and codex share the same usage limits now?” Claimed Shared Pool (one instance): One commenter relayed that integrated Codex shares the ChatGPT usage pool and that long-running Codex goals consume the same budget. “If you’re using Codex inside ChatGPT… then it shares the same overall ChatGPT usage pool for the relevant model… Long-running Codex goals and chats both count toward your available usage.” Fear of Loss of Separate Allowances: Many users worry that merging will consume chat credits or remove separate Codex quotas; some threaten to switch services. “I am using Codex only because it doesn't touch my chat credits. If they merge this, I'm out.” That was actually reassuring because it told me that I wasn’t the only one who was confused. When large numbers of experienced users are asking the same basic questions, it usually means the transition hasn’t been explained very well. People generally adapt to new software without much trouble when they understand the direction it’s going. They become frustrated when they’re left trying to guess how all the pieces fit together. As I kept experimenting, I noticed something else that deserves more attention. ChatGPT Classic and the new ChatGPT application don’t just present different interfaces. They also appear to represent different ways of using your subscription. Ordinary conversations continue to work in Classic, while the Work and Codex features use agent capabilities that have their own usage limits. That distinction matters because it affects how I will use

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]

Is the edit image endpoint broken right now?

In our infra we have services that call OpenAI's generate images and edit images endpoint. Since this morning we've been getting errors when trying to call the edit image endpoint (via API): Invalid response body while trying to fetch https://api.openai.com/v1/images/edits: Premature close https://status.openai.com/ does not show any issues specifically related to the API or image generation endpoints. Just tried in ChatGPT and it also seems to fail when trying to edit images (generation from scratch works fine). Is anyone else facing similar issues right now? submitted by /u/Kydje [link] [comments]

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]

If everyone can create, then are online businesses dead?

Let me explain. If the barrier to entry before AI was the timeline to completion + Software Development Knowledge. Now that these are both non-existent with AI. Everyone can build something. Everyone can execute the "idea". Now the barrier to success is marketing/users, but if AI can automate that too, with HeyGen or any new UGC styled content creation. Then that barrier is removed. Since you can just output content faster than traditional startups/builders. So what's left? We have IRL jobs, IRL specifically reffering to Construction, Tradies, etc. Vocational jobs. Now those guys can implement AI whether they do or not is another question. So the question i guess is. If everyone can have an Idea. Create it. Execute it. and then Market it. What's left? before f(a)ble 5 was taken down. This pretty much became the reality, it's still the same now with Opus, but slower and not as good reasoning. While F5 was up, I went on deepdive with F5 hours before it was taken down, and asked it what business could we do. A specific vertical. Short Answer is - well there isn't. We ended up on either buying an In Person Service Based Business or YouTube. I guess you could add video games to this too. Single Player. Story based stuff. Ecommerce eaten up by bigger companies. China dominating. Apps can be created with a click of the button. Once Gen Alpha enters. They will just make things for their workplace if it hasn't been implemented already. Any new tool once could theorise will be implemented by either Higgsfield, Anthropic, Gemini, etc. What do you think? Has AI made access to development so easy that at this point. Either invest in in person service based skills to start a job, or do we move into online consumer focused entertainment? Even with games, the only ones that may do well are the ones that can write a really strong story, but even then F5 wrote me a Film Themed Video essay script and it was one of the best things Ive ever seen. It just doesn't have the ability to select the footage...YET. (Finding sections of a clip from a video to use as the broll for the timeline) submitted by /u/FoxExeYt [link] [comments]

What really pulled Fable 5, and why it's bigger than Claude

TL;DR: With one letter and no hearing, the US government had Anthropic pull its most powerful public model for everyone, Americans included. That off switch is real, and it is only the most visible piece of a larger machine for deciding who may use frontier AI at all. Summary: On June 12, 2026, the US government ordered Anthropic to block its most powerful publicly available AI model for all foreign nationals, and to comply Anthropic pulled it for everyone, Americans included. It caps a chain of steps through 2026 that turned frontier AI into something the state can switch off, and back on, at will. Every powerful technology before it, from encryption to the phone network to the population registry, ran the same arc: built for one purpose, then seized as control infrastructure in the name of security. Open-source models are not the escape they look like, because the real choke point is the few players with the chips and power to train a frontier model, the easiest layer to control. The machinery to decide who may use the best AI already exists in pieces. This is the moment before someone assembles it. Wall of text: On Friday, June 12, 2026, at 5:21pm, the US Commerce Department sent Anthropic a letter. By the end of the night the most powerful AI model the company had ever released to the public, Fable 5, was dark for everyone on the planet, Americans included. Anthropic did not decide to pull it. It was ordered to, with no hearing and no public reason, and it complied within hours. The directive also named Mythos 5, the sibling Anthropic had only ever opened to a set of vetted organizations. The order targeted foreign nationals, but Anthropic could not separate users by nationality without blocking a huge share of its customer base, including its own foreign-born staff, so it shut both models down entirely. Taken alone, that's a single export-control action. Placed in sequence, it's the latest step in a pattern: Anthropic is becoming, in practice, an extension of the US government. Not by choice. By structure. Anthropic said almost immediately that it was working to restore access, so by the time you read this Fable 5 may well be back. If it is, none of this weakens. The argument was never that the models stayed down. It is that a government took them down at will, by letter, and was obeyed within hours. Putting them back only proves the other half of the same power: access is now the state's to grant and to revoke. The sequence Late 2025 into early 2026. Anthropic refuses to let the Pentagon, the US Department of Defense, use its models for mass domestic surveillance and fully autonomous weapons. Feb 27 to Mar 5, 2026. The Pentagon designates Anthropic a "supply chain risk," a label historically reserved for foreign adversaries, never before applied to a US company. This wasn't a quiet bureaucratic judgment. A US federal judge, Rita Lin, later found it an apparent attempt to "punish" Anthropic for exercising its constitutional rights and blocked it. An appeals court then reversed the block, and the case remained unresolved. The retaliatory character isn't just my read on it. A court said so on the record. April 2026. Anthropic launches Mythos Preview, its most capable cyber model, and declares it too dangerous for general release. Access is restricted to vetted "trusted organizations" under Project Glasswing. Anthropic chose the initial partners. But the US government, including the National Security Agency (NSA), was among the first several dozen organizations to get access. Early June 2026. Glasswing expands to roughly 200 organizations. Anthropic says the expansion followed "close collaboration" with its partners, the security industry, open-source maintainers, and the US government. Around the same time, the Financial Times reports that the NSA is readying Mythos for offensive cyber operations, with about half a dozen Anthropic engineers embedded inside the agency, though the report did not establish whether the model was being used in live operations. (To be clear, this is Mythos Preview, the restricted cyber model, not Mythos 5, the general model named in the June 12 directive.) June 2, 2026. President Trump signs an executive order asking AI companies to "voluntarily" give the government early access to their most powerful models, up to 30 days before public release, and lets the government help choose the "trusted partners" who receive that early access. The order explicitly disclaims any mandatory licensing or pre-clearance. On paper, nothing is compulsory. June 12, 2026, 5:21pm Eastern time. The government shuts the models down. Anthropic disputes the basis, saying the cited "jailbreak" surfaced only minor, already-known vulnerabilities that other public models, including OpenAI's GPT-5.5, find routinely. It complied anyway. None of this means the government's worry is imaginary. A model that can find and exploit software flaws at machine speed is a genuine national security pr

Anthropic spent a week arguing it should control who uses its most powerful model. Then the government used that exact argument against it. A timeline.

This post covers the Fable 5/Mythos 5 suspension as a product and policy event affecting Claude users. It is not intended as political commentary. Posting this as a neutral timeline because the facts are doing enough work on their own. I'll keep my own take out of it and let people connect the dots. Sources linked where I have them; correct me if I got anything wrong. The setup June 9, 2026 - Anthropic launches Claude Fable 5 and Mythos 5. Fable is its first broadly available "Mythos-class" model, described as the most capable model the company has ever released to the public: large gains in software engineering, knowledge work, vision, scientific research, and long-running autonomous tasks. Mythos 5 is the same underlying model with some safeguards lifted for trusted cyber and biology users. The framing at launch is the now-familiar Anthropic premise: this model is powerful enough to help defenders and researchers, and powerful enough to help attackers and competitors. So access has to be mediated. Some requests get downgraded to Opus 4.8. Some traffic loses zero-data-retention treatment. And there's a 30-day retention policy on Mythos-class models for trust and safety. What the system card actually said This is the part that kicked off the developer backlash, before the government got involved. Page 13 of the Fable 5 / Mythos 5 system card describes interventions for "frontier LLM development" requests (pretraining pipelines, distributed training infra, ML accelerator design). The detail that matters: these particular safeguards were designed to be hidden from the user. Fable would keep responding, but its effectiveness was deliberately limited via prompt modification, steering vectors, or PEFT. Estimated to affect ~0.03% of traffic. So: you pay for the top-tier model, you get an answer, and for a specific category of work the model has been quietly made worse without telling you. The system card also notes this safeguard helps enforce Anthropic's terms against using Claude to build competing models. Reactions worth reading: Simon Willison objected to a model that silently corrupts answers to slow research that might conflict with the provider's goals. Nathan Lambert framed it in safety terms: a model that becomes less capable automatically and without notice is itself a kind of misalignment. The core problem people raised: silent degradation breaks evaluation. If you get a weak answer, you can't tell whether the model is weak, your prompt is bad, or the provider changed the computation behind the scenes. Anthropic's response: after the backlash (Wired, Engadget reported it), the company reversed the visibility decision. Flagged requests would now be either refused outright or visibly rerouted to Opus 4.8, and Anthropic apologized for making the wrong tradeoff. Note what changed and what didn't: the visibility changed, the underlying restriction on frontier AI-development work stayed. The other complaints (separate from the hidden stuff) Broad safety filters firing on benign input. Reports of refusals on the first turn of sessions whose only input was "hello". An immunologist reported the word "cancer" being flagged as a biosecurity risk. Someone reported Fable refusing 200/200 ProgramBench tasks. When a filter trips, the request silently reroutes to a weaker model, which some users said made Fable effectively unusable for legitimate cyber/bio work. 30-day retention. It applied to organizations that previously had zero data retention on Console, Claude Code Enterprise, and third-party cloud surfaces. Practical effect: teams doing sensitive engineering had to choose between the best model and their existing data terms. The turn June 12, 2026, 5:21pm ET - Anthropic receives an export control directive from the US government, citing national security authorities, ordering it to suspend all access to Fable 5 and Mythos 5 for any foreign national, inside or outside the US, including Anthropic's own foreign-national employees. Compliance under normal service being impossible, Anthropic disables both models for all users. All other models stay up. Per Anthropic's statement: the letter included no specific detail of the national security concern. Their understanding is the government saw a method of jailbreaking Fable 5. Anthropic reviewed a demonstration and says it surfaced a small number of previously-known minor vulnerabilities that other public models (it names OpenAI's GPT-5.5) can find too. Axios reported the government side: a letter from Commerce Secretary Howard Lutnick placing the models under export controls, an administration official saying the action followed a jailbreak claim from another company, and that the government had previously tried to get Anthropic to pause the release. Anthropic's objection, in its own words and paraphrased: a narrow potential jailbreak is too thin a basis to recall a commercial model used by hundreds of millions. And critically, it says it

Fable 5: What $600/Hour of Productivity Looks Like

I had a TypeScript project. 200K lines. It ran. The architecture was aging — ORM that should've been ripped out, Redis and MQ that were relics of early over-engineering, bloated DDD layering when the core logic really just needed Postgres. I knew all of this. Never touched it. Doing this refactor with Opus 4.8 or GPT 5.5 would've taken me 4–5 days. Decompose business boundaries, design the migration plan, rewrite module by module, run tests, fix regressions. As a solo operator, those 5 days had a real opportunity cost. The code works, so let the tech debt sit. That's the call I made. That call held for six months. Until I got access to Fable 5. Two Prompts First prompt: I laid out the general refactoring approach — kill the ORM, slim down the DDD layers, pull Redis and MQ responsibilities back into Postgres, rewrite the core. I also said my approach might not be optimal and asked it to help me decompose. Fable asked me a few questions back. Not the customer-service kind like "which modules would you like to keep?" — questions that cut straight to business pain points: whether a particular async queue's consumption order carried business semantics, whether a caching layer existed for performance or to work around a legacy consistency bug. I answered, and the plan was locked. Second prompt: execute according to the plan and spec. Three hours. Refactor complete. Not just "complete" — along the way it independently found and fixed several hidden bugs in the old architecture. The kind you know exist but never bother with because they don't affect the main flow. It cleaned them up on its own. How It's Actually Different from Previous Models If you've used Claude Code, you know the scene: model hits a complex bug, fixes A, B breaks, fixes B, C breaks, then it starts spinning in an ever-shrinking local context, confidently declaring "this should fix it" each time, while you watch the terminal output and know — it's lost the global picture, stuck in a dead end arguing with itself. That's when you step in. Pull it out, re-inject context, maybe even roll back code and manually point it in a direction. You're essentially acting as its "working memory prosthetic" — using your judgment to maintain global coherence on its behalf. This is the default collaboration mode. You've probably gotten used to it. You might even think "this is just how AI-assisted coding works." Fable doesn't work like this. I'd previously used Fable to solve a Mac font rendering issue — the kind of messy problem tangled up in system environment, font cache, and application config. Opus's approach: list possible causes based on known experience, try them one by one. When results don't match expectations, move to the next candidate. Like traversing a decision tree. Fable did something entirely different. It first constructed a hypothesis, then designed a verification experiment — not "let's try this and see if it works," but "if my hypothesis is correct, then doing X should produce observation Y." When the observation didn't match, it didn't jump to the next solution. It went back and revised the hypothesis itself. This distinction sounds subtle, but the felt difference is enormous: one is searching for an answer, the other is understanding the problem. Same thing during the refactor. When it hit an unexpected dependency, it didn't get sucked in. It stepped back, re-examined how the current refactoring path related to the overall plan, and judged whether to adjust the local approach or revise the plan itself. This behavioral pattern, honestly, is very close to how a senior engineer works. Some Numbers Fable 5 bills at API rates. My 1.5 hours of intensive use ran about $900. The full refactor, without hitting limits, would've been 3 hours — API cost under $2,000. That works out to roughly $600/hour. My Claude Max subscription includes 5 hours of Fable quota. In practice, I hit the wall around 1.5 hours — not because time ran out, but because request density was too high and the quota burned faster than clock time. Stripe reportedly used Fable 5 to complete a 50-million-line Ruby migration in a single day. After Getting Cut Off When Fable was disabled, I switched back to Opus. How to describe it. Not "going back to an older tool." More like driving on a highway for three hours and suddenly being forced onto a country road. You know the country road gets you there too, but your driving rhythm has already changed. You instinctively try to work the Fable way — give a high-level intent, let the model decompose and verify on its own — then reality pulls you back: this model needs you to decompose for it, needs you to verify for it, needs you to yank it out when it gets stuck in a dead end. I posted on Threads: "My productivity is held hostage by the LLM. Habits are hard to break. Back to thinking for myself." That was self-deprecating humor. But also true. My entire working model is built on AI tooling. The leverage has been work

Is there any free platform similar to Google Flow that allows to USE gpt-image 2 ?

Hi redditors. So I love the concept of google flow specially the control it gives is really helpful. I use it frequently to generate images. But it fails to maintain exact facial consistency most of the time and drains so much time to fix it. I see the latest GPT-IMAGE 2 model is doing really good at maintaining face consistency. I have a Gpt subscription, but there is no official platform for GPT that allows me to login with my gpt account and gives me full control in image generation similar to Google flow. I've seen Higgsfield, openArt ai etc. That offers similar services like flow, But they have their own subscription & credit system. I don't wanna buy any new subscription right now. I've got a decent amount of API credits from some third party API providers. The api works on VS Code or antigravity. But Couldn't find any suitable platform to use the API keys and use GPT-Image 2 model and generate images using the credits i already have. Here's a list of platform i already tried but failed : [chatbox ai, lobechat, openrouter chatroom, typingminds, cherry studio, jan etc.] Can anyone help me solve this problem ? submitted by /u/Drak-Shadow-005 [link] [comments]

Claude ran out mid-debug and I wanted to throw my phone so I did this

You're 2 hours into a problem. Claude actually understands your codebase, knows the file structure, remembers what you already tried. Then — context limit. Dead. Now you're on ChatGPT. Except now you're typing: So I'm building an Android app, accessibility service, the overlay is stable but the parser is— And GPT is giving you generic garbage because it doesn't know any of the 2 hours of context Claude had. That re-explanation killed my momentum every single time. Got fed up and spent a weekend vibecoding a fix with Claude — ContextDrop. You save your project context once and reload it into any AI later. When Claude dies mid-session you load that saved context into GPT or Gemini or Grok in 2 taps and you're actually continuing, not starting over. Also cuts tokens hard. Stop feeding Claude your whole backstory every new chat when you can just reload tight context and get straight to the problem. What do you actually do when you hit the limit mid-problem — restart, or switch and re-explain? submitted by /u/ENMA_KITETSU [link] [comments]

After 10 years as an engineer, the thing I'd teach new vibe coders first: build tools with Claude Code that cost zero tokens to run

There's a saying: when all you have is a hammer, everything looks like a nail. When all you've ever used to build software is an LLM agent, tokens are a simple and easy solution to many software problems.. but perhaps not always the best or most efficient tool for the job. There's nothing wrong with it. My goal in this post is to give you another tool for your tool belt, one that reaches further than you'd expect. By the end I'll get to the neural network Claude built me while I cooked dinner, that doesn't cost a single token to run. Aright, so let's think about coding before LLMs and AI Agents. What was it? Just writing instructions for computers to follow exactly. Pretty much automation. Persisting data, moving it around, automating equipment and machinery. The word used for it was "deterministic". Meaning, given the same inputs it would (for the most part) always give the same output. So if you wanted to write a script to do something, given the same data, it should produce the same results. It could be brittle, but it was still amazing. A simple example I've used before: Imagine you are a calculator app and need the ability to add two numbers. There may be a function called add() that takes in a and b and returns a + b. You could call add(1,2) a million times in a row and it would always return exactly 3. Every single time. It's deterministic. Let's fast forward to now: we have LLMs and AI Agents. They flip that whole deterministic aspect of coding on its head. If you give an LLM a prompt, there is absolutely no guarantee that you'll get the same result each time. The cool and interesting thing is you could make a call to an LLM a million times with the prompt "Add 1 and 2 and give me the result". How confident are you that the response would be identical every single time? It would probably give you some variation of 3 most of the time. Or even every time. But just the number? What about some additional "Sure! I can do that! Let me add those numbers together for you: it's 3" or just returning "3" (probably not likely, LLMs are too verbose). And how many times have you created a prompt and added something like "only return the output" or "be concise" and it kind of worked. But only sometimes. This point is sufficiently beaten to death, but hopefully it makes it clear: LLMs are non-deterministic. And let me make one point, non-determinism is not a bad thing! In fact, quite the opposite! It's what makes LLMs and AI agents so magical. You can add a prompt with misspellings, bad grammar, vague terms, and chances are your point will get across and you'll get the results you were looking for. With deterministic code, that's typically not the case. But there's a symbiotic relationship between the two. A yin and yang. They complement each other so well. And that's what this post is all about. Bringing that relationship to your attention and putting words to it. Here is my hypothesis, (and it could be completely wrong, but hey I'm having a lot of fun writing this either way): folks who are new to coding and were introduced to it via vibe coding have probably only had experience with the LLM side of coding. The non-deterministic side. If that resonates with you I would love to bring the deterministic side of coding to your attention and show you how they complement each other. Let's show, not tell Alright, I've been speaking vaguely, let's be more specific and use an example. I'm going to show a common use case and give both the deterministic and non-deterministic approach. Let's say you're very interested in the Dungeon Crawler Carl book series (I loooove that series.. well the audiobooks. Completely burned through them all :D) and want to know when there is new information on the next book coming out and you want to automate the process: The non-deterministic way Your first instinct might be to go this way. What way is that? Have an LLM web search the website daily and let you know if there are any changes. This is a completely valid approach and there are several real benefits: it works every time, even if the website changes you get very tailored responses/it can summarize any changes that were made but what are the drawbacks? it spends tokens every single time (quite expensive) can be a bit slow (but honestly probably not that bad) The deterministic way So then how else could you approach it? You could write a script that scrapes the specific Dungeon Crawler Carl page on the website that has updates and just check to see if anything changed. Meaning you just have the previous text and the text from today. If different, alert you so you can just go read the page. (or it could just send you the new text, you can do this a bunch of different ways but you get my point). I'll start with the drawbacks for this one: it can be brittle. What if the site changes? What if the text updates but doesn't give any real information? you have to set it up to run yourself (whether that's a cron job

GitReel: Turn any PR into a short narrated video (open-source tool)

EDIT: I realized that the example video wasn't very helpful since the change is trivial, but it's been much more helpful with more complex PRs especially AI-written ones. PR review is my bottleneck now. The agent ships the change in minutes, then I'm stuck reading the entire diff trying to understand what actually changed, how the architecture shifted, and what parts deserve extra scrutiny. So I built GitReel. It makes the agent turn a PR into a short narrated video. It shows the shape of the changes, draws the architecture, calls out potentially risky areas, and gives an overall verdict. I watch the video first to get a high-level overview, then jump into the code. It's been a much faster way to review AI-generated changes than starting from the raw diff. Attached is an example reviewing a PR from Zod. The voice isn't great, but everything runs locally. No API keys, no external services. Better voices can always be plugged in later. Install the skill: npx skills add mohasarc/gitreel Then run the skill in your agent: /gitreel Repo: https://github.com/mohasarc/gitreel Would love feedback on the demo: Is the video format useful? What parts felt valuable vs noisy? Thoughts on the narration, pacing, and visuals? What would make this more useful in your own review workflow? More broadly, do you think video is a good medium for understanding PRs, or should code review stay text-first? submitted by /u/Hot_Resident2361 [link] [comments]

Fable has been intentionally mega-nerfed for AI research activities

See page 13 at the model card pdf: https://www-cdn.anthropic.com/d00db56fa754a1b115b6dd7cb2e3c342ee809620.pdf "In light of the ability of recent models to accelerate their own development, we’ve implemented new interventions that limit Claude’s effectiveness for requests targeting frontier LLM development (for example, on building pretraining pipelines, distributed training infrastructure, or ML accelerator design). Using Claude to develop competing models already violates our Terms of Service, but enforcing this restriction through our safeguards avoids accelerating the actors most willing to violate these terms." So they're openly saying the model is intentionally less useful for certain AI research topics. For the last few weeks especially, I've seen people in my research area complain that whenever conversations get into model training, infrastructure, scaling, distributed systems, or frontier research, the model suddenly feels dumb. Now there are active disclaimers against this. Are we supposed to delegate powerful AI to only corporations? feels like an artificial stiffle in competition submitted by /u/Main-Figure-8764 [link] [comments]

Anthropic is secretly degrading Fable 5 when it thinks you’re building frontier AI, and calling it “safety”

Anthropic just admitted something so blatantly anti-competitive that I’m genuinely shocked its legal department allowed it into a public system card. With Fable 5, Anthropic has introduced safeguards targeting work related to frontier LLM development. That includes things like pretraining pipelines, distributed training infrastructure, inference research, and ML accelerator design. That alone would be controversial, but it would at least be understandable if Anthropic handled it like every other product restriction: Refuse the request, tell the user why, and then suspend the account if they are violating the terms. Give legitimate researchers a way to appeal false positives. Instead, Anthropic explicitly says: “These safeguards will not be visible to the user.” Fable does not display a refusal. It does not notify you that it has switched models. It does not tell you that your session has been classified as suspicious. It just becomes less effective. Anthropic says this may be accomplished through prompt modification, steering vectors, or parameter-efficient fine-tuning. Anthropic may secretly make the model worse if it thinks your work could help develop a competing frontier AI system. It will continue letting you use the product without telling you that anything changed. That is covert sandbagging. It completely destroys the reliability of the model as an engineering tool. Imagine you are building a legitimate inference engine. You are not training a frontier model. You are not distilling Claude. You are not violating Anthropic’s terms, but your code contains all the scary classifier words: GPU kernels. KV caches. Quantization. Distributed inference. Model routing. Memory allocation. LoRA adapters. Attention optimization. Anthropic’s automated system falsely decides your work is related to competing frontier-model development. You then spend $20,000 in API credits working through a complex performance problem. The model gives you subtly worse architecture advice. It repeatedly misses an allocator bug. It writes patches that look plausible but fail under load. It steers you away from the correct design without ever issuing a refusal. You have no way to know whether: your architecture is wrong, the model is naturally struggling, your prompt is inadequate, or Anthropic has secretly activated a commercial safeguard against you. So you keep paying. Your engineers keep debugging. Your company keeps burning money. Eventually, you discover that the service was intentionally degraded the entire time. You think that company is not going to demand its $20,000 back? You think nobody is going to sue? The direct financial claim would be almost comical. The customer paid for access to Fable 5, received intentionally restricted performance, was never notified that the restriction had activated, and incurred measurable costs because the intervention was specifically designed to remain invisible. Anthropic will undoubtedly point to its terms of service and argue that customers are prohibited from using Claude to develop competing models. Fine, then enforce the terms evenly... A terms-of-service violation does not require turning your product into a hidden adversarial participant in the customer’s engineering workflow. If the request is prohibited, refuse it. If the account is violating the agreement, terminate it. What you do not get to do is accept payment while covertly supplying a degraded version of the service and denying the customer the information necessary to stop spending money. We all know false positives are not some obscure hypothetical here. The boundary between “building a competing model” and “building legitimate AI infrastructure” is not remotely clean. Inference engines are not foundation models. Agent orchestration systems are not foundation models. Long-context memory systems are not foundation models. GPU allocators are not foundation models. Evaluation frameworks are not foundation models. All of them involve technical concepts that overlap heavily with frontier-model development. I am currently using Fable 5 while working on MABOS, an operating architecture in which language models are components. I am not building a competing foundation model, but the system includes local inference, model orchestration, long-context memory, LoRA training, GPU memory management, autonomous coding loops, and a Rust runtime. Will Anthropic’s classifier understand that distinction every time? Maybe. How would I know if it didn’t? So far, Fable has worked extremely well on the project. My workflow also has external verification. The model does not get to declare victory because it wrote a convincing paragraph. It has to modify the code, run the actual smoke tests, retrieve the real logs, diagnose failures, and continue until the tests are genuinely green. If it suddenly starts sandbagging, I will probably detect the behavioral change. Most customers will not. They

PullMD v3: I let Claude design the MarkItDown integration, and it argued for keeping three of our own converters instead

About six weeks ago I posted PullMD here: a self-hosted Docker stack that turns any URL into clean Markdown, with an MCP server so Claude Code / Desktop / claude.ai pull pre-cleaned content instead of burning context on HTML boilerplate. v3.0.0 is out, and it's a bigger jump than the version number suggests. Short version: PullMD is no longer just a URL reader. It now converts documents, images, audio and YouTube videos to Markdown as well, and the default output got leaner. And no, don't worry - I'd like to think I haven't enshittified the original thing. Everything that worked before still works, (almost) unchanged. More on that "almost" below. How it started A boring personal itch. I had a pile of HTML files saved on disk that I wanted to hand to Claude, and figured PullMD already does the extraction, so why can't I just drop them in. So I added local file conversion: drag-and-drop on desktop, file picker on mobile, same Readability + Trafilatura pipeline. Local files are never cached, no share link. A few days later Microsoft released MarkItDown, and the next step was obvious: if I can take HTML files, why stop there. PDF, Word, PowerPoint, Excel, EPUB. So we wired MarkItDown in as a sidecar. Then we ripped three of its converters back out MarkItDown is good at the boring part: parsing document formats. For three other paths, Claude made the case for keeping our own instead - and once the reasons were sitting there in the code, pulling them was an easy call. Audio. MarkItDown's default audio path hands the file off to a cloud speech service. For a self-hosted tool we wanted that to be the operator's choice, not a default - so audio runs against any OpenAI-compatible endpoint you configure: a local faster-whisper / Ollama, a Groq Whisper, OpenAI, whatever. Nothing leaves your box unless you point it there. YouTube. MarkItDown's converter calls the transcript API outside its try/except, so a blocked or transcript-less video throws and takes the whole conversion down - you even lose the title and description that were already in the page HTML. No proxy support either, and YouTube rate-limits datacenter IPs. So we kept our own keyless handler: title + description + transcript, configurable timecodes and chunking, language preference, a proxy option, and a graceful fallback that still returns metadata when the transcript is gone. Image captioning. Rather than route captioning through MarkItDown's own LLM client, we put the vision call in our own provider layer: any OpenAI-compatible vision endpoint - a local Ollama / LLaVA, OpenAI, Gemini via a compatible gateway (defaults to gpt-4o-mini). Zero coupling, so a MarkItDown update can't break it - and if you only want media and no document conversion, you don't have to run the MarkItDown container at all. The principle we wrote into the project notes: use MarkItDown for file formats; keep the fragile, third-party-dependent paths in our own hands. What's actually new in v3 Documents → Markdown - PDF, DOCX, PPTX, XLSX, EPUB, ZIP, CSV, JSON, XML. By URL, by upload (POST /api/file), or drag-and-drop in the PWA. Needs the MarkItDown sidecar; leave it out and web pages work exactly as before. YouTube transcripts - title + description + full transcript, no API key. Images & audio → Markdown - opt-in, local-model-friendly, off by default (no model calls until you set a key). High-quality PDF tables (OCR) - PDFs convert free through the sidecar by default; for table-grade output there's an opt-in OCR tier (?pdf=ocr, reference provider Mistral OCR at ~$0.002/page, your own key, falls back to the free path on failure). Opt-in so it never silently costs money - and no, I didn't bundle a 4 GB local OCR engine with a 60-second cold start; it's a pluggable endpoint if you want one. Clean body by default - the one breaking change (the "almost" from up top). The body is now just # Title + content; source URL, fetch date and metadata moved into the YAML frontmatter, so nothing's duplicated and agents read fewer tokens. One-line opt-out: PULLMD_SOURCE_HEADER=true. Frontmatter field allowlist - trim the YAML to just the fields your pipeline reads. Everything past plain web extraction is opt-in and degrades gracefully. Configure nothing and v3 behaves like v2 with a cleaner body. Upgrade / self-host mkdir pullmd && cd pullmd curl -O https://raw.githubusercontent.com/AeternaLabsHQ/pullmd/main/docker-compose.yml docker compose up -d # → http://localhost:3000 Self-hosters on v2.x: clean-body is the only breaking change, MIGRATION.md has the opt-out. :latest now tracks v3; pin aeternalabshq/pullmd:2 to stay on the v2 output format. How it got built Same as v1: Claude Code wrote essentially all of the code, mostly with Opus 4.8. What I actually contributed was the planning and the pushback. The workflow was the superpowers plugin end to end: brainstorming to pin the design before a line of code, writing-plans to turn that into a structured plan, then sub