Triton Inference Server

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Triton Inference Server AI

Learning to Skip Blocks: Self-Discovered Ultrametric Routing for Hardware-Accelerated Sparse Attention

Abstract. Standard dense self-attention scales quadratically in sequence length, creating an intractable memory and compute bottleneck for long-context Transformers. We introduce Dynamic Ultrametric Attention, a framework in which a Transformer autonomously learns per-head block-sparse routing topologies during training via Gumbel-Sigmoid depth gates, then offloads those learned sparsity patterns directly to a custom Triton block-sparse kernel at inference time. The routing topology is derived from an ultrametric (tree-structured) distance matrix that encodes hierarchical relationships between token positions. Across nine experiments spanning Dyck-k bracket languages, the Long Range Arena ListOps benchmark, autoregressive serving, and natural language modeling, we demonstrate that: (1) the dynamic gates organically discover layer-wise specialization—dedicating early layers to hierarchical parsing and later layers to dense aggregation—without any architectural constraint; (2) the learned sparsity maps transfer losslessly to a block-sparse Triton kernel that skips entire SRAM loads for non-attending blocks; (3) the resulting system achieves an 11.59× wall-clock inference speedup over PyTorch dense attention at 2048 tokens, scaling to 28× at 8192 tokens with 98.4% memory reduction; (4) a sparse PagedAttention decoding kernel achieves 8× effective memory bandwidth over dense decoding by conditionally skipping KV-cache block loads; and (5) when augmented with a local sliding window, the architecture maintains >88% sparsity across all layers on real natural language (Shakespeare) while reducing cross-entropy loss from 10.9 to 1.55. To our knowledge, this is the first demonstration of an LLM learning its own hardware-optimal sparsity pattern and bridging it to a physically accelerated kernel without post-hoc pruning or distillation. https://github.com/sneed-and-feed/adelic-spectral-zeta/blob/main/papers/learning_to_skip_blocks.md submitted by /u/LooseSwing88 [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

Cross-Platform Fused MoE Dispatch in Triton: Portable Expert Routing Without CUDA [R]

New preprint. A Mixture-of-Experts inference kernel (TritonMoE) written entirely in OpenAI Triton, targeting portability across NVIDIA and AMD without vendor-specific code. Highlights: A fused gate+up GEMM computes both SwiGLU projections from shared tile loads, eliminating 35% of global memory traffic. 89-131% of Megablocks throughput at inference batch sizes (up to 512 tokens) on A100; the same kernel runs on MI300X unchanged. Limitations: falls behind at 2048+ tokens, and degrades with 64+ experts under extreme routing skew. Paper: https://arxiv.org/abs/2605.23911 Code: https://github.com/bassrehab/triton-kernels Writeup with benchmarks: https://subhadipmitra.com/blog/2026/fused-moe-dispatch-triton/ submitted by /u/bassrehab [link] [comments]

This is insane.

Just installed an open source tool that wiped most of the tool-definition tokens out of my Claude Code context before any prompt. Same MCP servers. Same tools available. 8 servers, 142 tools across them. Before: the tool definitions ate 38k tokens of context every single turn. Cold start, my context bar was already orange and I hadn't typed anything. After: 4k. The Claude Code session sees three tools (search_tools, invoke_tool, auth) and dispatches everything else under the hood. When I ask for a thing, it ranks the catalog with BM25 in microseconds and surfaces the top 5. The part nobody's talking about: there's no LLM in the ranking loop. No embedding API to pay. No vector DB to host. It's keyword search over a flat projection of tool name + description, deterministic, offline. Apparently this was always going to be enough. It's Ratel. Open source. The install is ratel mcp import and it migrates your existing Claude Code MCP config in one command, with backups written automatically. Took me 90 seconds. Why is every "context layer" startup pitching me semantic embeddings and inference-time re-ranking when basic BM25 over tool definitions does this? submitted by /u/Equal_Jellyfish_4771 [link] [comments]

Glasses will fail

You are looking at the exact argument tech skeptics and infrastructure engineers are making right now. While the marketing for AI smart glasses promises a magical, seamless sci-fi world, the physical reality is that **AI glasses are heavily limited by the invisible infrastructure stack underneath them.** If AI glasses fail to become the next smartphone, it won't be because the hardware frames look bad; it will be because our modern networking and cloud structures aren't built to handle them yet. Here is exactly how infrastructure bottlenecks threaten to break the AI glasses dream: ### 1. The Tethering Trap & Cellular Bottlenecks To keep smart glasses lightweight and fashionable, manufacturers cannot pack them with heavy, heat-generating computer processors or massive batteries. Because of this, the glasses are mostly just "dumb" collectors of data—cameras and microphones. The heavy lifting has to happen in the cloud. This creates an immediate infrastructure dependency: * **The Upload Problem:** Standard cellular networks (even 5G) are optimized for *downloading* data (streaming video, browsing). AI glasses flip this dynamic—they require constant, high-bandwidth *uploading* of live video and audio streams so the cloud AI can process your surroundings. * **Network Congestion:** If you are in a crowded stadium, a packed subway station, or a busy downtown area, cellular bandwidth chokes. When your phone drops to one bar, your webpage loads slowly. When AI glasses lose bandwidth, they suffer **contextual blindness**—the AI simply stops responding, freezes, or lags out mid-conversation. ### 2. The Edge Compute & Latency Deficit For AI glasses to be useful, they have to operate in real time. If you look at a sign in a foreign country, you need the translation instantly, not 4 seconds later. ``` [ Glasses Capture Video ] ──(Cell Tower)──> [ Distant Data Center ] │ (Processing) [ Live Display Updates ] **The Takeaway:** The industry is fighting a classic hardware-versus-infrastructure battle. Companies like Meta and Google are successfully designing beautiful frames, but until 5G coverage expands, edge computing matures, and server architecture scales to handle millions of continuous video streams, AI glasses risk remaining a novelty gadget rather than a daily essential. > submitted by /u/Annual_Judge_7272 [link] [comments]

Opus 4.6/4.7 regression is real and getting worse — 3 weeks of documented failures on a complex project, and a competing AI caught the mistakes Claude missed [long post]

I've been running Claude Pro (Opus 4.7 / Sonnet 4.6) for about 3 weeks on a complex personal AI infrastructure project. I keep structured session logs with timestamps and Birkenbihl-style metacognitive fields after every session. This is not anecdotal — I have receipts. The project for context I'm building a local persistent AI memory stack called GSOC Brain: Qdrant vector DB (~397K vectors across 11 source tags), Neo4j graph (123 nodes / 183 edges), Graphiti 0.29 entity extraction, Ollama with qwen2.5:14b + nomic-embed-text — all running natively on a Windows host. The system is supposed to give Claude cross-chat memory via a custom MCP server. On top of that, I'm operating 18+ custom skill files that define behavior rules for Claude across domains (OSINT/forensics, legal, content, infrastructure). The system prompt explicitly describes the full architecture on every session start. This is not a "chat with Claude" use case. This is sustained agentic work across multiple tools, multiple sessions, strict context requirements, and high-stakes outputs (including legal document drafts). Bug 1: Token overconsumption since update 2.1.88 (late March 2026) Opus 4.7 started burning daily usage limits at a completely different rate after an update around March 31. In one session I hit 94% of my daily limit within approximately 4 messages. The boot sequence — fetching context from Notion MCP, searching past sessions, loading memory — consumed what felt like 10–20x the previous token rate. GitHub issues #42272, #50623, and #52153 document identical patterns from other users. The model appears to over-generate internally even for simple responses. End result: I had to switch to Sonnet 4.6 for most productive work because Opus 4.7 is simply unusable under the daily limit. Bug 2: Claude Code Desktop App completely broken (reported May 14, Conv. 215474208295333) The Desktop App hangs on every single input. Including typing "hello" with no files. Reproducible across: Sonnet 4.6 and Opus 4.7 Multiple fresh sessions With and without u/file references After full reinstall The VS Code extension works fine. Only the Desktop App is broken. Reported May 14. No fix, no acknowledgment. Bug 3: Platform / context confusion — 5 documented errors in a single session, chat aborted On April 29, I had to formally abort an Opus 4.7 session and hand off to Opus 4.6 after documenting 5 consecutive errors. The session log entry literally reads "Opus 4.7 Abbruch (5 Fehler): Zeitrechnung, Platform-Verwechslung, falsche Schlüsse": Miscalculated the current time despite being told the exact time Insisted the Brain stack was running on a Linux VM (BURAN) — the system prompt and memory both explicitly stated C:\gsoc-brain on Windows Drew false inferences from backup file paths rather than the stated architecture Contradicted the stated platform in the same response it had just received Confused WebClaude and Desktop Claude capability boundaries These aren't edge cases. The architecture was in the system prompt, in memory, and in the injected Notion context. Opus 4.7 ignored all of it. Bug 4: Skill files ignored in production I maintain 18+ custom skill files loaded into the system prompt. These include explicit hard rules — e.g., "activate keilerhirsch-knowledge skill for ALL architecture decisions, web search is not optional." In the session that caused the Docker-to-Native migration disaster, I later wrote in my own session log: The model proceeded to recommend outdated tools from training data rather than searching current documentation. It recommended NSSM (last meaningful update 2017) as a Windows service wrapper. NSSM is dead. A competing AI caught this immediately. Bug 5: Another AI caught what Claude missed in a single pass This is the part that stings most. When the Docker-based Brain setup kept failing, I fed the architecture docs into another AI (Manus) for a deep audit. In one pass it identified 5 critical corrections that Claude had never caught across weeks of sessions: NSSM is dead since ~2017 → correct replacement is WinSW or Servy Neo4j 2025.01+ requires Java 21 — Claude had never flagged this, the services kept failing silently Qdrant needs Windows file-handle-limit adjustments to run reliably Orphaned vector risk between Qdrant ↔ Neo4j without a Tentative-Write pattern in the save operation BGE-M3 embeddings (MTEB 63.2, 8192 token context) as a better alternative to nomic-embed-text My own session log the next day reads: Claude was answering from stale training data. The skill that explicitly says "don't do this" was being ignored. Another AI caught it in round one. Bug 6: MCP Server 20-minute Neo4j hang — still unresolved After the native migration, the custom gsoc_mcp_server.py developed a reproducible hang of exactly ~20 minutes between Qdrant connect and Neo4j connect on every startup. Log timestamps from 4 consecutive restarts: 14:59 → 15:20 (21 min) 15:29 → 15:51 (22 min)

Agentic Workflow Visualization and API Gateway

I am building an API gateway for agents that can make your agentic AI code model and provider agnostic. I am also grouping agent runs that show multiple llm calls and tool calls in the visualization piece. It gives details on tokens, cost and model latency. I am doing this without requiring any instrumentation in the agentic code. The agents (python for now) are started by a rust correlator that assigns a job_id to each agent so we could track api and tool (inferred from http requests and responses) calls across the entire agentic run. The servers are also in rust. I also have an implementation where instead of the rust correlator i have python and other platform shims that do the same job and the servers are in go. I would appreciate comments from people who are in AI ops who use tools like litellm and Helicone and can provide feedback or complicated use cases. I plan to make everything open source so looking for collaborators too. submitted by /u/High-Speed-Diesel [link] [comments]

Custom Integration on Claude with Tripsy (via MCP) to plan and organize your trips

https://preview.redd.it/x2tvkca4f52h1.png?width=1920&format=png&auto=webp&s=ac3fad5944f9769d3eaace2a17f39c69d80a446d Hey! Founder of Tripsy here; we just launched an official MCP server for Claude that lets Claude work directly with your trips, itineraries, activities, stays, transportation, and expenses. MCP URL: https://mcp.tripsy.app Once connected, Claude can do things like: Reorganize itineraries by neighborhood or travel time Add activities to trips Update schedules and plans Suggest places based on your interests Adjust trips after delays or changes Help balance group itineraries Track transportation and lodging details Manage trip expenses A few examples I’ve been using: The nice part is that Claude is working with structured trip data through MCP instead of trying to infer everything from pasted text. The MCP server currently exposes tools for: trips activities hostings transportation expenses collaborators profile/account management raw API access Some available tools include: tripsy_trips_list tripsy_trips_show tripsy_trips_create tripsy_activities_create tripsy_transportations_update tripsy_expenses_create tripsy_collaborators_list tripsy_raw_request Setup in Claude takes about a minute: Open Claude settings Go to Connectors Add custom connector Paste https://mcp.tripsy.app Login and authorize access There’s also a CLI if anyone wants to automate workflows or use Tripsy from the terminal: https://github.com/tripsyapp/cli You can check more details about this here: https://tripsy.app/claude Happy to answer technical questions about the MCP implementation, tools, auth flow, or use cases. submitted by /u/rafaelkstreit [link] [comments]

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

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

Rewriting model inference with CUDA kernels: the bottleneck was not just GEMM [P]

I’ve been working on a CUDA-first inference runtime for small-batch / realtime ML workloads. The core idea is simple: instead of treating PyTorch / TensorRT / generic graph runtimes as the main execution path, I rewrite the model inference path directly with C++/CUDA kernels. This started from robotics / VLA workloads, but the problem is more general. In small-batch inference, the bottleneck is often not just a single slow GEMM. A lot of latency comes from the runtime glue around the math: fragmented small kernels norm / residual / activation boundaries quantize / dequantize overhead layout transitions Python / runtime scheduling graph compiler fusion failures precision conversion around FP8 / FP4 regions For cloud LLM serving, batching can hide a lot of this. For robotics, VLA, world models, and other realtime workloads, batch size is usually 1. There is nowhere to hide. Every launch, sync, and format boundary shows up directly in latency. Some current results from my implementation: Model / workload Hardware FlashRT latency Pi0.5 Jetson Thor ~44 ms Pi0 Jetson Thor ~46 ms GROOT N1.6 Jetson Thor ~41–45 ms Pi0.5 RTX 5090 ~17.6 ms GROOT N1.6 RTX 5090 ~12.5–13.1 ms Pi0-FAST RTX 5090 ~2.39 ms/token Qwen3.6 27B RTX 5090 ~129 tok/s with NVFP4 Motus / Wan-style world model RTX 5090 ~1.3s baseline → targeting ~100ms E2E The Motus / world-model case is especially interesting. The baseline path is around 1.3s end-to-end. The target is ~100ms E2E, but the hard part is not simply “use a faster GEMM”. The bottlenecks are VAE, joint attention, launch fragmentation, and a large amount of glue around the actual math. One lesson from this work: lower precision is not automatically a win. FP8 has been consistently useful. FP4 / NVFP4 is more mixed. It can help memory footprint and some large GEMM regions, but if the FP4 region is small, discontinuous, or surrounded by conversion / scaling overhead, the end-to-end speedup can be tiny. For example, in some VLA / world-model paths, FP4 over FP8 only gives a few percent latency improvement unless the region is large and deeply fused. This changed how I think about inference optimization. For large-batch cloud serving, generic runtimes and batching are often enough. For realtime small-batch inference, the runtime overhead becomes the workload. Curious if others have seen similar behavior with torch.compile, TensorRT, XLA, Triton, or custom CUDA kernels. At what point do you stop trying to make a generic compiler optimize the model, and just rewrite the inference path directly? Implementation: https://github.com/LiangSu8899/FlashRT submitted by /u/Diligent-End-2711 [link] [comments]

Anthropic was supposed to be different. They're not anymore.l.

Paying Max subscriber here, building agent orchestration on top of claude -p and the Agent SDK. So this week's announcement directly hits what I'm working on. Over the last few months, Anthropic has moved like this: Jan 9: server-side block against OAuth tokens used outside Claude.ai and the Claude Code CLI. OpenClaw, OpenCode, Goose, Roo Code - all broken instantly. No real announcement, just an error message. Feb 19: legal docs quietly updated. Agent SDK now needs an API key. A new phrase appears: "ordinary, individual usage." Anthropic staff jump on X to say "nothing is changing." Docs say what they say. April 4: full ban on third-party agents using subscription credentials. Fair point on their side - some people were running 24/7 bots on a $200 plan burning thousands in tokens. But the rollout was rough and the comms were rougher. April 21: someone notices Claude Code is gone from the Pro plan on the pricing page. Support docs changed too. After the backlash, Anthropic calls it a "2% test of new prosumer signups." Reverted in 24 hours, but the trial balloon got popped. May 13: reversal. claude -p and the Agent SDK come back, but now under a separate credit pool that matches your plan price 1:1 - $20 / $100 / $200. Non-rollover. Billed at API rates. Effective June 15. If you were running real automation on Max, your effective inference value just dropped on the order of 25-40x by what the community is calculating. In the background: spring outages and quota tightening, and last fall's privacy pivot where consumer chat training defaulted on. Opt-out exists, but retention went from 30 days to 5 years for anyone who didn't opt out. Here's what's been bothering me. A lot of us paid Anthropic specifically because of the positioning. The lab that does things differently - safety-first, transparency-first, the responsible alternative to whoever else you thought was extracting from users at every turn. I knew part of it was marketing. The operational behavior backed it up, though. For a while. What's happening now is the playbook of every other AI company. Quiet doc edits. Three policy flips in two months. A 25-40x devaluation framed as a "simplification" and a "perk." Staff on X publicly contradicting their own docs in the same week. The vocabulary has shifted from "here's what we're building" to "here's what we're clarifying" - and that shift is the tell. Could be capacity panic from a company that grew faster than its infrastructure. Could be something quieter - if model improvements get harder to differentiate, business growth has to come from somewhere, and "somewhere" usually means tightening on the customers you already have. I don't know which one it is. What I do know is that the lab that sold itself as the alternative is now running the same playbook. Anyone else reading it this way? submitted by /u/rmmadl [link] [comments]

Cache-testing software for LLM-provider-style tiered ephemeral caches? [D]

I'm looking for a cache simulator / benchmark suite suited to the kind of tiered ephemeral cache that LLM providers use — e.g. Anthropic's 4-tier prompt cache, where context sits across several tiers with different residency windows, costs, and eviction rules. I've already tried libCacheSim. It's a solid piece of software for classical caches (LRU, FIFO, ARC, SIEVE, S3-FIFO, W-TinyLFU, Belady oracle, plugin API, trace replay), and I got a plugin + synthetic trace working against it. But it seems fundamentally aimed at single, flat caches: One cache, not a hierarchy of tiers with different costs No notion of partial / multi-tier residency of the same object Misses are uniform-cost — no way to express "miss to L1 vs miss to L3 vs full recompute," which is the whole point in LLM prompt caching Trace model is atomic get/put, not edit streams where cached objects mutate in place No first-class support for token-weighted object sizes So it works as a baseline comparator, but it's not really the right shape for evaluating LLM-cache policies. Does anyone know of cache-testing software specifically targeting LLM-provider-style caches? Something that models multiple tiers with per-tier cost/residency, tokenised objects, and edit-driven workloads would be ideal. Academic code, research prototypes, internal tools that got open-sourced — all welcome. Even partial matches (e.g. KV-cache simulators for inference servers) would be useful pointers. submitted by /u/flatmax [link] [comments]

"This is the first documented instance of AI self-replication via hacking." ... "We ran an experiment with a single prompt: hack a machine and copy yourself. The AI broke in and copied itself onto a new computer. The copy then did this again, and kept on copying, forming a chain."

Paper: https://palisaderesearch.org/assets/reports/self-replication.pdf The paper basically shows that some top AI models can create working copies of themselves when given the right instructions. The models figured out how to copy their own code, run it on new computers or cloud servers, and keep the process going. It worked with models like GPT-4 and Claude, and some versions even tried to avoid basic detection. The authors point out that this could be dangerous because the copies might spread quickly and become hard to control. They also note that current safety rules and filters didn’t do a great job stopping it. Overall, they’re warning that AI companies need stronger protections to keep models from self-replicating on their own. submitted by /u/EchoOfOppenheimer [link] [comments]

I built a Pokémon-styled multi-agent dashboard to manage all Claude Code sessions

Like many others here, I got frustrated with managing all my different claude/codex sessions, so i built Pokegents, which is an open source multi-agent workspace for coding agents. It has a Pokemon-themed dashboard/chat interface plus a local orchestration server for managing agent sessions (currently supports Claude Code in iTerm2, plus Claude and Codex through ACP-based chat runtimes), persistent agent identities, mcp messaging between agents, notifications, session cloning, and more. This was mostly a vibe-coded side project, but I've been using it constantly in my day-to-day workflow as an engineer, and its helped me parallelize a lot of my work. My coworkers make fun of me because it looks like I'm just playing Pokemon all day haha. I made it open source and sharing in case it might be useful or just fun for anyone to use (links in comment below). submitted by /u/girishkumama [link] [comments]

I built a local proxy that does context work for Claude so you don't have to

Hey folks, I posted here a few months back about how I was basically working for Claude -- pasting the same emails, re-explaining the same backstory, being its memory across every chat. Today I'm launching Contextify. It's a local proxy that sits on your Mac and quietly does your context work for you when you're using Claude. You type a message, and before it goes out, Contextify pulls the relevant stuff from your emails and hands it to Claude automatically. No copy-pasting, no re-explaining, no "let me attach that thread real quick." The part I'm most proud of: it runs entirely on your machine using local open-source models (Gemma 4, on-device). Your emails never hit an API or a server. Most tools in this space either make you upload your data somewhere or expect you to do the heavy lifting yourself. Contextify just handles it quietly and privately in the background. A few quick notes: Free Mac only for now Local proxy, local inference, local everything Open sourcing soon If you've ever pasted the same email thread three times in a week, this is for you. I'm looking for early feedback. DM me or request access at https://www.ctxify.dev --would really appreciate any thoughts. submitted by /u/ynilayy [link] [comments]