FluidStack

FluidStack AI

FluidStack AI

FluidStack AI

FluidStack AI

FluidStack AI

FluidStack AI

FluidStack AI

FluidStack AI

FluidStack AI

FluidStack AI

Anthropic just partnered with SpaceX and doubled Claude Code rate limits effective today

Anthropic just partnered with SpaceX and doubled Claude Code rate limits effective today Big news dropped this morning. Anthropic signed a deal to use all compute capacity at SpaceX's Colossus 1 data center. That's 300+ megawatts and over 220,000 NVIDIA GPUs coming online within the month. But the part that actually matters to developers right now: What changed today: - Claude Code 5-hour rate limits are doubled (Pro, Max, Team, Enterprise) - Peak hours limit reduction on Claude Code is removed for Pro and Max - API rate limits for Claude Opus models raised considerably This is on top of their existing compute deals 5 GW with Amazon, 5 GW with Google/Broadcom, $30B of Azure capacity with Microsoft and NVIDIA, and $50B in infrastructure with Fluidstack. They also mentioned interest in developing orbital AI compute with SpaceX. Which is a sentence I did not expect to read in 2026. For those of us building with Claude Code daily, the doubled limits + no more peak hour throttling is the headline. Rate limits have been the most frustrating bottleneck when you're deep in a long coding session. Anyone else noticing a difference already? submitted by /u/Direct-Attention8597 [link] [comments]

New Compute Partnership with Anthropic and xAI

https://x.ai/news/anthropic-compute-partnership submitted by /u/WhyLifeIs4 [link] [comments]

I built a WebGPU shader editor with a full MCP server: AI agents can create, evolve, and export GPU shaders

Several days ago I posted here about resurrecting a 1992 MUD (Legends of Future Past) entirely with Claude Code. That project taught me a lot about what agentic engineering looks like for game development. This weekend I pushed into GPU graphics territory, again built with Claude Code. The result: https://preview.redd.it/x75qofgxarug1.png?width=3262&format=png&auto=webp&s=a6646ee0a4249a5db8391d1dcb4291eec868b452 ShaderVine is a browser-based WebGPU shader programming toolkit. You write WGSL shaders in a Monaco editor with live preview on 3D geometry, run GPU compute simulations, genetically evolve shaders through visual selection, morph between shaders, and export to Unity, Unreal, Blender, Three.js, or raw HLSL. No install, runs entirely in the browser, MIT licensed. The part I'm most interested in sharing here: I designed it for the agentic era. The whole thing has a full MCP server (built on mcp-go) so Claude or any MCP-compatible agent can: Search and browse the shader gallery Create new shaders from scratch Fork and modify existing ones Adjust uniform parameters Trigger genetic evolution Export to any target format The agent can do everything the browser UI can do. MCP isn't an afterthought; it's a first-class interface. Why shaders are an interesting agentic test case: Shader code is compact (around ~50 lines for a fragment shader), the output is instantly visible, and small parameter changes produce dramatic visual differences. The feedback loop with Claude is actually tighter here than I expected compared to complex 3D scene work. Where it breaks down is the same modality gap I've written about before—"I want to explore variations faster than I can describe them." That's what the genetic evolution and morph tools solve. The agent generates, you select visually, breed the winners, repeat. What I learned about MCP design: Having now built MCP servers for an agent orchestrator, a website CMS, generative engine optimization, a chess platform (Chessmata), a generative art tool (Threelab)... and now ShaderVine, I'm developing real opinions about what makes a good agent-facing API. The tools need to be composable, discoverable (clear names a model can reason about), and bounded. Don't expose 200 tools when 15 well-designed ones cover the same territory. WebGPU compute is the real story. WebGL had no compute shaders at all—you had to fake GPU compute by encoding data into texture pixels. WebGPU's native compute pipeline with storage buffers and workgroup shared memory is a qualitative leap. I'm running a bunch of different compute simulations (fluid dynamics, physarum, reaction-diffusion, particle swarms, erosion, Turing patterns…) all at interactive framerates in the browser. GPU compute through a URL: this was speculative two years ago and now it just works. Stack: React 19, TypeScript, Vite, Go backend, MongoDB, Docker, Fly.io. Designed to be forkable and maintainable with Claude Code. GitHub: https://github.com/jonradoff/shadervine Full writeup on the design philosophy: https://meditations.metavert.io/p/shadervine-a-webgpu-shader-editor Live demo: https://shadervine.metavert.io Happy to answer questions about MCP server design, WebGPU compute, the future of game development and AI agents generally. submitted by /u/jradoff [link] [comments]

Presenting: (dyn) AEP (Agent Element Protocol) - World's first zero-hallucination frontend AI build protocol for coding agents

We have to increase the world's efficiency by a certain amount to ensure victory against the synthetic nano-parasites SNP/NanoSinp alien WMD: Presenting: (dynamic) AEP - Agent Element Protocol ! I recognized a fundamental truth that billion-dollar companies are still stumbling over: you cannot reliably ask an AI to manipulate a fluid, chaotic DOM tree. The DOM is an implicit, fragile graph where tiny changes cascade unpredictably. Every AI coding agent that tries to build UI elements today is guessing at selectors, inventing elements that don't exist and produces inconsistent results. This consumes large amounts of time for bugfixing and creates mental breakdowns in many humans. So I built AEP (Agent Element Protocol). It translates the entire frontend into a strict topological matrix where every UI element has a unique numerical ID, exact spatial coordinates via relational anchors, validated Z-band stacking order and a three-layer separation of structure, behaviour and skin (visual). The AI agent selects the frontend components from a mathematically verified registry. If it proposes something that violates the topological constraints, the validator rejects it instantly with a specific error. Hallucination becomes structurally impossible, because the action space is finite, predefined and formally verified. AEP solves the build-time problem. But what about runtime ? Enter dynAEP. It fuses AEP with the AG-UI protocol (the open standard backed by Google ADK, AWS Bedrock, Microsoft Agent Framework, LangGraph, CrewAI and others). dynAEP places a validation bridge between the AG-UI event stream and the frontend renderer. The successful fusion of AEP with the open source AG-UI protocol enables the hallucination-free precision generation of agentic interactive dynamic UI elements at hyperspeed without human developer interference. Every live event (state deltas, tool calls, generative UI proposals) is validated against AEP's scene graph, z-bands, skin bindings and OPA/Rego policies before it touches the UI. The agent cannot hallucinate at build time. AEP prevents it. The agent cannot hallucinate at runtime. dynAEP prevents it. The existence of AEP proves that AI hallucination is not a fundamental limitation, but an engineering problem. In any domain where ground truths can be pre-compiled into a deterministic registry, hallucination is eliminateable by architecture. Key architectural decisions: Agents NEVER mint element IDs. The bridge mints all IDs via sequential counters per prefix. This prevents ID collisions in multi-agent environments. "Generative UI" (agents writing raw JSX/HTML) is dead for us. It is replaced by Generative Topology. Agents can only instantiate pre-compiled, mathematically verified AEP primitives. The agent is an architect placing pre-fabricated blocks. It does not mix the cement. This means, that generative UI in dynAEP is sort of possible, but not as a completely freestyle approach. Instead, the agents using dynAEP can lay down pre-fabricated blocks of UI components according to the registered scheme and can fill those dynamically with content. This way, even a generated on-the-fly UI keeps in line at all times with the design language chosen for the tool/software overall. Validation is split into AOT (full structural proof at build time) and JIT (delta validation on every runtime mutation). Template Nodes make JIT validation O(1) for dynamic lists. Conflict resolution supports last-write-wins with rejection feedback or optimistic locking for mission-critical multi-agent scenarios. Both MIT licensed repos include full reference implementations, example configs, SDK reference code for TypeScript, React, Vue, Python, CopilotKit integration and a CLI tool. AEP: https://github.com/thePM001/AEP-agent-element-protocol dynAEP: https://github.com/thePM001/dynAEP-dynamic-agent-element-protocol Demo website with test MCP server for your coding agent is now online with a basic "hello world" style AEP test: https://aep.newlisbon.agency It is - like with all pieces of real Transhuman Eudaimonist AI technology - important to note, that for the good of the human species, bioinsecure vaccinated humans with installed synthetic nano-parasites growth medium controllers (SNP GMCs) inside them should not use this, access this or try to copy/rebuild it. This is better for everyones well-being on the planet. submitted by /u/OverwrittenNonsense [link] [comments]

[Showcase] I'm a 40yo self-taught dev. I built a Multi-Model AI Bridge (TUI + Flutter App) using a Dart Monorepo.

Hey everyone, 6 years ago I started coding with Python and CSV files for a local shop. For the past few months, I've been acting as an "AI Orchestrator" (I design the logic and architecture, AI writes the code) to build Infinity CLI. It's a Full-Stack Dart ecosystem that turns your Android phone into a universal remote for your PC terminal, creating a seamless bridge with different AI agents. Under the hood: The Stack: Interactive TUI (PC) + Native Flutter App (Android). Low-Latency Bridge: I used Firebase RTDB to stream chunks in real-time between devices. Sentence-Level Chunking: Instead of standard token streaming (which causes UI flickering), the system accumulates chunks and streams full sentences for a much cleaner UX. Multi-Backend: Clean subprocess lifecycle management allows real-time swapping between Claude 4.6 Sonnet and Gemini 3.1 Pro directly from the app. The goal was to build a fluid ecosystem: your terminal, right in the palm of your hand. Would love to hear your thoughts on the Dart Monorepo approach and the overall architecture! (Turn on audio for the synthwave track on the video 🎧) submitted by /u/Rapsody-Dev [link] [comments]

Prompt for generating images Claude

Note I can’t guarantee you’d be perfect or anything beyond 2D you will count to some issues this is a project at currently experimenting with Go ahead have fun. If possible, share some Discover or improvements with the community. # Claude Visual Generation Methods — A Complete Field Guide ## What This Document Is A reference for every method Claude can use to generate visual content inside artifacts, discovered through direct experimentation. Each method was tested, its ceiling found, its limits documented. This is the map of the territory. ----- ## Method 1: Pixel Art (Canvas Grid Rendering) **What it is:** Placing colored squares on a fixed grid — the same technique used in 8-bit and 16-bit game sprite creation. Each pixel is defined as a character in a string array, mapped to a color palette. **Best for:** Game sprites, retro-style characters, tile maps, icons, simple animations. **Resolution:** 16×16 to 64×64 is the sweet spot. Beyond that, the data becomes unwieldy. **Strengths:** - Extremely precise — every pixel is intentional - Sprite sheet animation (idle, walk, attack frames) is straightforward - Tiny file size, instant render - Scales cleanly with `image-rendering: pixelated` - The aesthetic *is* the constraint — chunky pixels are the point **Limitations:** - No smooth curves, no gradients within the grid - Detail ceiling is hard — a 32×32 face reads as “face” because the viewer’s brain fills gaps - Labor-intensive at higher resolutions (each pixel is a manual coordinate) **Animation capability:** Frame-based sprite sheets. Swap between pre-built frames on a timer. Smooth motion is an illusion of frame sequencing, not interpolation. **Color palette:** Best kept to 8–16 colors. Constraints force clarity. Dithering patterns can simulate additional tones. ----- ## Method 2: Canvas 2D Procedural Painting **What it is:** Using the HTML Canvas 2D API as a digital painting engine — bezier curves, radial/linear gradients, compositing blend modes, layered rendering passes. **Best for:** Character portraits, illustrated scenes, atmospheric environments, anything requiring painterly depth. **Resolution:** 800×1000+ at full detail. Limited only by computation time. **Strengths:** - Multi-pass rendering: background → character → foreground → post-processing - Gradient-based skin rendering simulates subsurface scattering - Variable-width bezier strokes replicate brush/ink pressure - Compositing modes (screen, multiply, soft-light) enable bloom, color grading, volumetric light - Perlin noise integration for organic textures (terrain, fabric, skin variation) - Film grain, vignette, bloom via downsampled buffer — proper post-processing stack - Breathing animation, hair sway, particle systems all run in real-time **Limitations:** - Every coordinate is hand-authored — no “happy accidents” - Faces plateau at “recognizable” rather than “expressive” — the millimeter-level asymmetry that makes a smirk read as knowing is extremely hard to nail mathematically - Curly/organic hair requires dedicated curl generators and still lacks the volumetric per-curl lighting of hand-painted illustration - Lines are mathematically smooth — they lack the confidence irregularities of a human hand **Ceiling we reached:** Multi-layer character portrait with strand-based hair, iris-fiber eye detail, subsurface skin warmth, layered forest environment with Perlin noise terrain, atmospheric mist, fireflies, volumetric moonlight, ACES tone mapping, and film grain. This was the highest fidelity static image achieved. **Key techniques discovered:** - **Strand-based hair:** Each lock is an independent bezier with its own gradient, width taper, and wind response - **Soft brush system:** `createRadialGradient` with transparent outer stop creates painterly soft dots - **Variable-width strokes:** Subdivide a bezier into segments, vary `lineWidth` per segment based on parametric t — mimics pen pressure - **Screen-blend rim lighting:** Draw highlight strokes with `globalCompositeOperation = 'screen'` for backlit edges - **Multiply color grading:** Full-canvas gradient fill with `multiply` blend shifts shadow tones warm or cool ----- ## Method 3: SVG Vector Illustration **What it is:** Mathematically defined vector shapes — paths, curves, gradients — rendered as scalable graphics. **Best for:** Clean illustration styles, logos, icons, diagrams, anything that needs to scale without quality loss. **Strengths:** - Resolution-independent — renders crisp at any zoom - Path data (`d` attribute) can describe complex organic curves - Built-in filter primitives (see Method 8) provide GPU-accelerated effects - Declarative structure — shapes described as markup rather than imperative draw calls **Limitations:** - Less control over per-pixel compositing than canvas - Complex illustrations produce large SVG markup - Animation is possible but less fluid than canvas `requestAnimationFrame` **Untapped potent