Inference

Inference AI

Inference AI

Inference AI

Inference AI

Inference AI

Inference AI

Inference AI

Inference AI

Inference AI

Inference AI

This is how I started using coding agents for DS/ML workflows [D]

https://i.redd.it/2zg99j8jd8ch1.gif I built Lemma. She plugs into your coding agent as an MCP server, one install and it has both her rules and her tools. Every session starts with her rulebook already loaded. From there your agent calls her tools to read, manage, and interact with a live Jupyter kernel, VS Code, PyCharm, or JupyterLab, instead of trusting whatever's sitting in a static .ipynb file. Try it free, it's just open source, no tiers: > npm install -g @tkpratardan/lemma > lemma What makes it different: 🧠 She reads the live kernel, not a stale .ipynb. 🚨 Audits, questions, and checks before you believe it. 🔌 One install, ten agents: Claude Code, Cursor, Codex, Copilot CLI, and more. 🧭 Rules, not vibes: baseline before complexity, time-ordered splits, seed everything. 🔁 Not clingy: lemma --uninstall unplugs her just as cleanly as the install plugged her in. Under the hood, for the builders: MCP server plus a persona/rules file, delivered however each host actually supports it, MCP instructions, a session hook, or a generated rules file, not one-size-fits-all. Live notebook access three different ways: VS Code's own notebook API, PyCharm via kernel + disk, JupyterLab via real-time collaboration. Bundled into one dependency-free file, so a plain git-fetch install doesn't crash on startup. Nine skills, one per kind of analysis question, EDA, baseline, causal, inference, leakage, review, and more. Would genuinely love feedback, especially where this falls short. GitHub: github.com/tkpratardan/lemma Star, fork, and contribute if you want to help push this further. submitted by /u/Spare_Suit3701 [link] [comments]

Masked depth modeling with sensor-validity masking: reports best RMSE on 7 of 8 masked/sparse depth benchmarks, plus a controlled encoder-init study[R]

The core idea in masked depth modeling is to treat the sensor's own missing regions as the masking signal rather than using random block dropout. Specular highlights, transparent surfaces, and textureless areas where RGB-D cameras return no valid depth become the natural training target. The model therefore learns on exactly the failure distribution it faces at inference. Robbyant, an embodied AI company under Ant Group, describes this framing in LingBot-Depth 2.0. Version 2.0 changes nothing in the training recipe except the encoder initialization and data scale. The encoder-init study is the clean experiment here: same MDM pipeline, same data curation, only the pretrained backbone swapped. Per the paper, the LingBot-Vision init wins on nearly every benchmark at ViT-L and on most benchmarks at ViT-g, with one concession: DINOv2 keeps an edge on the Hammer captures. The gap widens with data scale rather than washing out, per their scaling figure. They report best RMSE on 7 of 8 block-mask and sparse benchmarks and 6 of 8 real camera configurations across three capture suites (Hammer D435/L515/ToF, ClearGrasp D415/D435, and their own D415/D435/D455 set). They report the strongest numbers on the transparent-object ClearGrasp captures, with block-masked DIODE-Indoor RMSE roughly halving versus the 1.0 release. The attached images are screenshots from their paper (Tables 6, 7, 8 and a qualitative mirror/glass point-cloud figure); interactive point-cloud demos live on the project page. Depth 2.0 weights are not released, so none of these completion numbers can be independently rerun. Only the four Vision backbones are open under Apache-2.0 and checkable at https://github.com/robbyant/lingbot-vision, which hosts the paper and the open weights. The renders shown come from the vendor's comparison page. Does sensor-validity masking beat random masking for other sensing modalities, say lidar or thermal? That would test how general the framing really is. submitted by /u/Ok-Line2658 [link] [comments]

LingBot-Vision: masked boundary modeling for self-supervised pretraining (0.296 NYUv2 linear-probe RMSE at 1.1B vs 0.309 for DINOv3-7B, trails on ImageNet); weights in 4 sizes[R]

The idea: instead of masking random patches and hoping boundary structure emerges, the teacher predicts a dense boundary field online and the boundary-bearing tokens are forced into the student's mask, so the student has to reconstruct exactly the regions that can't be inferred by copying context. The boundary targets come from the teacher itself rather than labels or an external edge detector. Two design choices that look load-bearing: boundary fields are recast as per-pixel categorical distributions so the geometric branch can reuse the centering/sharpening machinery that keeps self-distillation from collapsing (continuous regression targets drift under an EMA teacher), and decoded segments pass an a-contrario validation test before they're allowed to supervise anything. Numbers, all self-reported (images): they report the best NYUv2 linear-probe RMSE of their comparison (0.296 at 1.1B/patch-16 vs 0.309 for DINOv3-7B), with segmentation on par with the distilled DINOv3 ViT-H+. The distilled ViT-L (0.3B) lands at 0.310 NYUv2, basically the 7B's number. Data budget per the report: 161M images, less than a third of DINOv3's samples. Where it loses in the same tables: ImageNet classification trails at giant and L scale (their B/S students lead their class on linear probe), ADE20K trails the DINOv3 family, KITTI favors the bigger models. The encoder-initialization study (last image) is the part I find hardest to dismiss: the exact same depth-completion pipeline trained on the same data, only the init swapped. The LingBot init wins across the board at ViT-L and on most benchmarks at ViT-g (they concede DINOv2 keeps an edge on the Hammer captures), and the data-scaling curve shows the gap growing rather than washing out as training data grows. What I'd want before treating the DINOv3 comparison as settled: they do run all baselines under one probe protocol, which helps, but a 0.013 RMSE delta is within what probe LR/resolution choices can produce, and there's no ablation against learned/hard-masking baselines (ADIOS/AttMask-style), which seems like the natural comparison for "mask the hard tokens". Checkpoints are public so the probes are cheap to rerun. Given the eval complaints around Ant's Ling-1T release, I'd treat the numbers as unverified until that happens. One thing I can't square: DINOv3 needed Gram anchoring to stop dense-feature degradation over long schedules, and this method keeps it, so boundary forcing looks complementary rather than a replacement. Anyone read it differently? Links: report https://technology.robbyant.com/lingbot-vision code: https://github.com/robbyant/lingbot-vision weights (4 sizes, Apache-2.0): https://huggingface.co/collections/robbyant/lingbot-vision submitted by /u/StillThese3747 [link] [comments]

CPU TTS benchmark with UTMOS MOS scoring: Kokoro, Supertonic, Inflect-Nano, and Kyutai's new Pocket TTS [P]

Sharing a CPU TTS benchmark with objective MOS scores in case it's useful for anyone evaluating small TTS models. Adding this because Kyutai's Pocket TTS is architecturally different from the others in the field and I hadn't seen a head-to-head with it yet. Models: Kokoro 82M (PyTorch and ONNX Runtime, StyleTTS2-inspired) Supertonic 3 at 2 and 5 flow-matching steps (Vector Estimator backbone) Inflect-Nano-v1 (4.6M param FastSpeech-style, tiny end of the spectrum) Pocket TTS (~100M param streaming LM over Kyutai's Mimi neural audio codec) Setup: Intel Xeon 8272CL, 4 cores, 15.6GB RAM. CUDA disabled at env level. ONNX sessions pinned to CPUExecutionProvider. Six configs, six text lengths (12 to 1712 chars), five timed reps per cell after a discarded warmup. 180 total runs. Every saved WAV scored with UTMOS (utmos22_strong) for objective MOS. Aggregate results: Config Mean RTF UTMOS Supertonic 3 (2-step) 0.121 1.53 Inflect-Nano-v1 0.145 3.48 Supertonic 3 (5-step) 0.240 4.32 Kokoro 82M (ONNX) 0.641 4.44 Kokoro 82M (PyTorch) 0.665 4.46 Pocket TTS 0.714 4.10 Findings I think are actually interesting: 1. Streaming LM architecture produces flat RTF scaling. Pocket TTS's RTF is 0.69 to 0.76 across the entire text length range. Because it emits audio tokens autoregressively at a steady rate, cost is linear in output length with no fixed overhead to amortize. Compare to Kokoro PyTorch, which climbs from 0.49 on tiny to 0.83 on long inputs, or Supertonic which goes the other way (0.36 on tiny down to 0.20 on medium) because of high per-call fixed overhead. If you're budgeting worst-case latency for an interactive system, flat is worth a lot. 2. UTMOS has a known failure mode on small vocoders. Inflect-Nano-v1 scored 3.48, which reads mid-pack. By ear it's buzzy and robotic. This is a documented issue: UTMOS rewards HiFi-GAN outputs for being clean even when they lack prosodic naturalness. Pocket TTS scored similarly (4.10) but sounds legitimately natural. The point isn't that UTMOS is broken, it's that a single quality number can't distinguish "clean and mechanical" from "clean and natural" on small models. Worth pairing with human listening or a naturalness-specific metric like NISQA. 3. Inflect-Nano has an undocumented ~15s output cap. The model config sets max_frames = 1400, which caps synthesis at ~14.93s regardless of input text length. Its RTF and throughput on long/paragraph/extended inputs are inflated because it's doing less work than the models it's compared against. Real comparison for that model is on tiny/short/medium only. 4. Kokoro ONNX vs PyTorch results reverse from the previous run. I ran an earlier version of this benchmark on AMD EPYC and PyTorch beat ONNX in aggregate. On this Xeon, ONNX is faster (0.641 vs 0.665). Same code, different silicon. AMD vs Intel kernel optimization differences at CPU inference are apparently real enough to flip the ranking. If anyone has replicated this on ARM I'd be curious. Zero-shot voice cloning as a capability that doesn't fit the benchmark axes: Pocket TTS can clone a voice from ~5 seconds of reference audio, zero-shot, on CPU. No other model in this field does this. I pinned it to a preset voice for the speed/quality comparison to be fair, so the cloning capability isn't reflected in the numbers. This is a real limitation of RTF-and-MOS-based comparisons: they can't capture capabilities that only one model has. Might want a separate speaker-similarity evaluation for a v2. Limitations: Single hardware platform English only UTMOS is one MOS predictor; NISQA or a listening panel would strengthen the quality claims Voice cloning quality was not evaluated No batched inference tested Disclosure: The benchmark harness was written by an AI engineering agent (Neo) from a prompt I specified. I chose the methodology, validated the outputs, and reviewed the audio. Mentioning it because it's relevant to how you'd want to weight the code. All code, raw CSVs (180 rows), MOS CSV (36 rows), and WAV samples are in the repo mentioned in the comments below 👇 Feedback on the protocol welcome, especially on the MOS methodology and what a proper voice-cloning eval would look like. submitted by /u/gvij [link] [comments]

Competence Gate: gating tool-use on a small model's internal confidence signal instead of its verbalised one — Qwen3.5-4B, open weights [P]

I made a 10MB LoRA adapter for Qwen3.5-4B plus a small orchestration layer. It decides, per query, whether to answer directly, search the web, or retrieve from your own local documents and it refuses to make things up when it can't verify an answer. It runs locally (Apple Silicon / MLX, with a GGUF build for llama.cpp/Ollama). Basically small instruct models are poor at telling users how confident they really are. They can't verbalise it and tend to say they are confident for everyhting. In my past research I tested seven 3-9b models and they all hit a confidence ceiling. But the information is there in the internal activations. The adapter reads the internal signal directly and gates tool use on it. The main elements are that: - it catches its own errors better than the base model's tool calling (d′ improvement of 0.46 (95% CI [0.01, 0.89])). Of the cases the gate flagged that the base model didn't, 87% were genuinely wrong answers. - it is less likely to leak your private queries to public search. A two-signal version routes personal information related questions such as "what did my discharge summary say" to a local retriever instead of a websearch. It cut the rate of private questions sent to public search from 22% to 10% (reduction 0.12, 95% CI [0.02, 0.22]). This is useful for those who are using the LLM for confidential docs. - every answer is traceable. When it retrieves, it cites the specific passage (report.md ¶2), verifies the answer is actually in that passage, and shows a confidence band. Worst case, it says "I couldn't verify that". It is built to say "I don't know," instead of lie. limitations: - Privacy result is n=60; the retrieval/competence dissociation is n=126 hand-authored items. Screened and CI'd, but small. - GGUF reproduces the MLX gate's decisions at --lora-scaled ...:8 (found by sweep — scale 1 does nothing; effective scale ≈ the training scale). Agreement 0.83 on a 24-item probe; disagreements are all conservative-direction (GGUF answers a couple of borderline items MLX would look up), and knowns never false-fire. Faithful on the safety-critical directions, marginally more conservative at the margin. - Serve-time confidence is coarse (grounded / declined / answered) — the distilled gate reads nothing at inference, so finer bands need probe access (offline). - Inherits Qwen3.5-4B's knowledge and biases. The gate governs when to trust the model, not what it knows. The approach isn't Qwen-specific — I started on SmolLM3-3B, and it should extend to other models and larger sizes. Repo (weights + code + model card): https://huggingface.co/synthiumjp/competence-gate-qwen3.5-4b Apache-2.0. It's an open research release. I hope people might find some use for it. Methodology and papers are cited in the model card. Genuinely interested in critique, it's screened work, so if there are any issues it be great to know. **** Update ***\* I ran the gate against external benchmarks it hadn't been tested on, and one use case did not survive. The gate does not improve grounded document QA — answering faithfully from a provided passage and abstaining when the passage doesn't support an answer. On SQuAD 2.0 unanswerables, fabrication was actually higher with the gate than without it. The reason is a example of construct specificity. "Knowing when to defer" is not one capability. There are at least two distinct signals hiding inside it: - Parametric competence: do I know this from my own weights? The gate reads this. It's what the probe was validated against. - Evidential grounding: is this answer supported by the passage in front of me? A different question, from a different information source. A probe validated for one carries no usable signal for the other. A parametric-competence signal applied to an evidential-grounding task doesn't just fail to help, it actually interferes by pushing toward answering and suppressing the base model's (Qwen's) own abstention. The base model already handles the easy case (0% fabrication when the passage plainly lacks the answer). The hard case (adversarial unanswerables) needs purpose-built grounded-abstention training, not a post-hoc firewall. The release is scoped to what's validated: parametric tool-call routing and privacy-aware retrieval routing. The "refuses to fabricate about documents" framing in the original post above is the part that doesn't hold. submitted by /u/Synthium- [link] [comments]

How to improve a 5-class Diabetic Retinopathy model (APTOS 2019) – Mixed predictions across classes[P]

Hi everyone, I'm a final-year Computer Engineering student building a Flask-based AI Diabetic Retinopathy Detection system. The web application itself is complete with patient management, authentication, dashboard, PDF report generation, prediction history, and AI inference. The only issue I'm facing is with the AI model. I'm using a 5-class Diabetic Retinopathy classifier trained on the APTOS 2019 dataset. Classes: No DR Mild Moderate Severe Proliferative DR The model predicts all five classes, but the predictions are inconsistent. Examples: Moderate is sometimes classified as Severe or Proliferative. Severe is often classified as Moderate or Proliferative and is rarely predicted correctly. Some fundus images from outside the APTOS dataset produce completely unexpected results. The model sometimes shows very high confidence (90%+) even when the prediction appears incorrect. Things I've already tried: Different pretrained models (including a ResNet50 trained on APTOS) ResNet152 implementation Correct preprocessing (RGB conversion, resizing, normalization) Verified class mapping Softmax confidence scores Test-Time Augmentation (TTA) Image quality validation Top-3 predictions instead of only one prediction I'm trying to understand whether this is: A domain shift problem between APTOS and other datasets? A limitation of the pretrained model? A preprocessing issue? Class imbalance? Or simply expected behavior in 5-class DR classification? I'm also considering using an ensemble (ResNet50 + EfficientNet + DenseNet), but it's difficult to find compatible pretrained 5-class diabetic retinopathy models. I'd really appreciate advice from anyone who has worked on retinal image classification or medical AI. My questions are: Is this level of class confusion common in diabetic retinopathy models? What preprocessing techniques made the biggest improvement for you (CLAHE, retinal cropping, illumination correction, etc.)? Has anyone significantly improved results using ensemble models? Are there any high-quality pretrained 5-class DR models that you'd recommend? If you were in my situation, what would be the first thing you'd investigate to improve prediction consistency? Any suggestions, GitHub repositories, pretrained models, research papers, or personal experiences would be greatly appreciated. Thanks in advance! submitted by /u/Delicious_Corner_754 [link] [comments]

I'm trying to implement CALM paper, and I have some questions. [P]

Hello, I'm trying to implement the Pocket TTS by kyutai-labs represented by this paper. Since they have didn't released the training/fine-tuning code. I'm trying to implement it on my own for learning some stuff. I have read the paper, tried to implement it with much more smaller parameters with smaller amount of data. I implemented this text to speech with one speaker on LJSpeech (1) and LibriSpeech clean subset but its hardly failing. For (1), Since it's a single speaker dataset I didn't added the voice cloning just simple text and target latents. flow matching loss became nearly 0.20 mse , EOS loss became very low like (x)e-(y) levels. But when infer with the model saved at 2800th epoch, It barily generating a meaningfull text even the text within its training set. Tried different techniques like Scheduled sampling for eliminate exposure bias (model was hallucinating sometimes and repeats same phrases twice), it didn't worked. Added std gaussian noise to ground truths, didn't worked. After struggling with lots of implementation I decided to move forward with quite larger dataset LibriSpeech because I thought that scale of the data was small. For (2), I read the paper again. No scheduled sampling, added the head multiplication etc, and implemented the paper in the librispeech dataset. I tried audio condition+ text tokens + BOS + target latents, and swapped the audio prompt with text tokens. I observed a tradeoff in this setup: if I put text tokens near to target latents, model generates better text but voice is not even close to audio prompt,and gibberish speak with better voice cloning when I put audio condition tokens near to target latents. And found out that loss is very spiky, and grad norm is exploding too you can see below the images. loss and lr values for setup 1 (LJSpeech) values for setup 2 (LibriSpeech) I used Pocket TTS' orijinal Mimi Audio Encoder by extracting it from Original model. What is your suggestions? Should I read paper over and over again? Should I increase the data amount by collecting from different sources(authors says that they used 88.000 hours of publicly available data)? Any system design problem? Trainings performed on RTX 5080 desktop gpu. I want to move on to bigger dataset but can't burn GPU credits for non-expected result. When should I increase dataset and start training on bigger clusters that could give me satisfyable results? submitted by /u/No-Motor-6274 [link] [comments]

Cerebras OpenAI deal capacity has effectively killed the waitlist for everyone else [D]

I’m pretty annoyed. We’re a small AI startup building a real-time coding agent. Our p95 latency requirements are tight (and self imposed, but thats the product). We need sustained high-throughput inference with ~1-2k tokens/second. Been on the Cerebras waitlist for months trying to get API access. We’re not doing training so don’t need a warehouse of H100s. We need fast, high-throughput ASIC inference for a specific production workload. Cerebras’ just went public and they basically have no compute how is that possible? Well turns out OpenAI and Cerebras for OpenAI to buy like $20b worth of these chips. This has effectively pre-allocated the vast majority of Cerebras’ near-term inference capacity to a single customer. I mean, none of us can compete with that The result is that this deal situation has made their API waitlist functionally infinite for anyone who isn’t a hyperscaler. Legit making me pull my hair out. submitted by /u/Kortopi-98 [link] [comments]

Kuma: compiling PyTorch models into self-contained WebGPU executables [P]

I've been experimenting with a compiler/runtime project that I'm not entirely sure is a good idea, so I'd love some feedback from people who've worked on deployment systems. The idea is to compile an exported PyTorch model into a self-contained package that contains: graph binary weights backend kernels (currently WGSL) runtime metadata A lightweight runtime loads that package and executes it directly in the browser with WebGPU. No Python, no server inference, and no dependency on a heavyweight runtime. Right now the attached demos are just neural video representations because they were easy to test, but the motivation is actually operator networks and scientific ML, where I like the idea of distributing a single portable artifact. The repo is here: https://github.com/Slater-Victoroff/Kuma I'm mostly looking for architectural feedback. Some questions I'm wrestling with: Is embedding backend kernels in the artifact a terrible idea? Is this solving a real deployment problem or just reinventing ONNX Runtime? Are there existing systems I should study that take a similar approach? If you were designing a deployment format today, what would you change? I'd especially appreciate thoughts from people who've worked on ONNX, IREE, TVM, ExecuTorch, MLIR, or similar compiler/runtime projects. submitted by /u/svictoroff [link] [comments]

Would having a dedicated programming language specifically for LLMs be a viable solution? [D]

What if there was a new programming language where the meaning of each token was so dense (or perhaps so specific) that an LLM could write robust code with fewer tokens and faster inference? Assuming there’s enough training data, do you think something like this allow an LLM to write better code faster? Rationale: 1) It would allow for faster inference. Fewer tokens required to do the same thing in Python = finish faster. 2) It would allow for more information in a 1M context window. Whatever you could fit in 1M tokens of Python, you could do 100x that in this theoretical language. 3) It would effectively remove the “noise” from human readable language (semi-colons, curly braces for example) which I would think would make the LLMs coding ability stronger. I could be wrong about this of course. submitted by /u/Spongebubs [link] [comments]

Bypass Connector Approval 3P Inference Mode

Hello! As I mentioned in the title, I'm in 3P Inference mode which means that I'm using my Snowflake Claude models from Claude Desktop because at my organization, we don't want to ask prompts directly to Anthropic due to security concerns. It works marvelously but the only problem is that it can't search on the web. I managed to create a Cortex Agent with the "web search" tool enabled and export it as an MCP server. I set the instructions to always invoke the tool when Claude considers it should search on the web. But the issue I've ran into is that it always prompts back with an approval request to use the connector. Is there a way to bypass this approval to make the overall experience more "smooth"? submitted by /u/Sea_Pen_1356 [link] [comments]

Stop asking Claude for "something creative." Ask it to find the lacuna.

TL;DR: If you ask an LLM for "a novel idea" you get beige mush, because the most probable answer is the average answer and novel is the opposite of average. Instead, make it map a field, find the axis everything secretly optimizes for, locate the cell that the structure implies but nothing occupies, and, the important part, name the force keeping that cell empty. I've been calling it lacuna prompting. It consistently gets sharper, less safe output than anything else I've tried. ______________________________________________________________________________________________________ I spent a long session with Claude trying to figure out why its answers feel like they hit a wall whenever I want a genuinely non-obvious take. Best framing we landed on: a model's knowledge isn't a list of facts, it's more like a near-continuous fabric with gaps in it. The word for a gap in an otherwise continuous thing is a lacuna, a missing tile in a mosaic where the surrounding pattern tells you what the tile should have depicted. That reframe is the whole trick. Don't ask the model to invent from nothing. Ask it to find the gaps in a fabric it already has, where the surround constrains what belongs there. Why the default is beige When you ask for "a creative idea," the model optimizes for the highest-probability response, which is by definition the most conventional one. "Creative" and "most probable" point in opposite directions, so you get something that sounds novel but is actually dead center. The safeness isn't the model being timid. It's regression to the mean wearing a costume. Lacuna prompting works because it forces the output to a specific edge of the space, where the boring center answer is visibly wrong and can't be used. The method Here's the actual procedure. Paste this, fill in the topic: Don't give me a novel idea. Run this on [TOPIC] and show your work at each step. 1. MAP THE FIELD. List the main existing approaches as points. Map them densely enough to see the shape. 2. FIND THE HIDDEN AXIS. What do almost all of them secretly optimize for? Name the one direction the whole field is sliding along without noticing. 3. LOCATE THE LACUNA. Find the cell the surrounding geometry implies should exist but is empty — usually the opposite pole of that hidden axis, or the centroid between clusters that none of them occupy. Describe what sits there. 4. NAME THE FORCE KEEPING IT EMPTY. This is the important step. Is the cell forbidden by the field's own incentives? Unrepresentable in its default mental model? Punished by something structural? If you can't name a specific force, you've found a boring gap, not a real lacuna — go back to 3. 5. SORT IT. Is it empty because nobody's discovered it, or empty because everything there fails? Admit you can't fully tell from inside, but give your read. 6. PROPOSE THE FILL at full conviction, and flag your confidence: is the surrounding pattern dense (strong inference) or thin (you're extrapolating)? The main drivers Step 4 (name the force) is the engine. Anyone can say "here's a gap." The value is diagnosing why the field bends away from it, an incentive, an accounting model, a measurement system, a tooling limitation that literally can't represent the missing thing. If the model can't name a force, the gap is usually boring. When a response drifts back toward safe, it's almost always because step 4 got thin. Push on it: "what's the force?" Step 6 (confidence flag) is the part everyone skips and shouldn't. Make it tell you whether the surround is thick fabric or a thin patch. A model will always produce a fill, that's the catch. It can interpolate just as smoothly over a real gap as over a hole that should stay empty (this is basically what a hallucination is: confident interpolation over nothing). It can't certify which it's doing. But it can tell you how dense the surrounding pattern is, and that's the single most useful piece of metadata for deciding which proposals to actually act on. Example Ask the normal way "give me a new marketing channel" and you get a list of stuff that already exists. Run the method and step 2 surfaces the hidden axis: nearly all marketing optimizes the funnel toward more. More attention, more reach, more conversion. Step 3 walks to the opposite pole: a discipline built on repulsion, where the KPI is who you drove away and the product is having survived the filter. Step 4 names why it's empty: the funnel model literally can't represent a technique whose success metric is a narrow top, and commission structures punish anyone who tries. That's a real lacuna with a named force, not "make a TikTok." Whether it's good is a separate question, which is the whole point of the last step. Caution The method finds the gap and proposes the fill. It cannot tell you whether the floor holds. That part (actually testing it in the real world) is yours, and it's not optional. The model hands you coordinates, not verdicts. If you treat the clean framing

I built an MCP server so Claude can query repo structure before opening files

I built a tool called Graphenium after repeatedly running into the same issue with Claude on medium-to-large repos. Claude is usually good once it has the right files in context. The weak part is the first few minutes of a session, where it has to reconstruct the shape of the project: search for a symbol read the file follow imports read another file summarize the area notice a missing dependency search again That is not Claude doing anything wrong. It just starts every conversation without a durable model of the repository. Graphenium is my attempt to give it one. It analyzes a repo once, stores the result as a graph, and exposes that graph through MCP. Claude can then use tools like: graph_stats architecture_summary query_graph get_neighbors shortest_path god_nodes summarize_file The intended workflow is not "never read source code." It is: ask the graph where to look open the relevant files then reason from the actual source That matters because the graph output is much smaller than dumping half a repo into the context window just to find the right starting point. Example setup: cargo install graphenium gm run . --no-semantic --no-viz gm setup claude AST-only mode runs locally and does not need an API key. It extracts repository structure using tree-sitter: files, symbols, imports, containment, methods, communities, hubs, and paths. There is also an optional semantic mode: gm run . --provider anthropic That pass can add inferred relationships such as calls, uses, implements, and depends_on. I am careful about trust boundaries here. Every edge has a confidence level: EXTRACTED deterministic static extraction INFERRED useful lead, verify before important edits AMBIGUOUS uncertain relationship, treat as a question So Claude can use the graph as a map, but should still read source before changing code. The repo also includes a Claude Skill at: skills/graphenium/SKILL.md That gives Claude guidance on when to call the graph tools, how to interpret confidence levels, and how to fall back to the CLI if MCP is unavailable. Repo: https://github.com/lambda-alpha-labs/Graphenium I am looking for feedback from Claude Desktop / Claude Code users. The main thing I want to know is whether this actually changes Claude's behavior: does it choose better files earlier, avoid irrelevant reads, and keep more context available for reasoning? submitted by /u/RevolverOcelot86 [link] [comments]

An ode to Opus 4.6

It's been a week and a half without Fable for almost all of us and I have used this time for some reflection. The pricing and access concerns were a lot to take in even before the feds pulled the plug, but for whatever reason this intermission keeps sending me back to February of this year. This was a real turning point for me. 4.6 dropped and the model was obviously pure fire at the time (similar to how fable felt for those three days), and with its help I became much more comfortable building and managing agents. This unlocked a hobby project I would have never attempted a year ago with a full time job and a family. Somewhere in these last few months the ceiling of what I could pull off by myself popped a quick exponential. I'm sure many of you can relate to quarters feeling like years in this space lately. In late April while on vacation for my kid's spring break, I couldn't sleep so I snuck down to the hotel lobby in the middle of the night to grind on my project. I remember clearly thinking during this time "there is no way this is going to last", always wanting to take advantage of my five-hour windows and make as much progress as possible. I guess I never paid much attention before and I was probably somewhat delirious, but I began to appreciate the "thinking" text that agents show us both in the terminal and desktop. Caramelizing... levitating... then for whatever reason (my project isn't rocket science) one of my agents shows me "thinking about concerns with this request". Just me and the night watch employee in the lobby and I probably look like a madman giggling to himself. I thought we need to get these out into the wild and put them on shirts. So I just dove in: What's up with all this thinking text you show. How do people sell shirts. Custom web dev or Shopify. Print on demand model. What's a cool logo. Generate it. Cool name. Taking a few turns about iconic AI visuals led me to the "Attention is All You Need" paper that spawned all of this. A little AI history lesson as the sun was starting to come up. Did all this in parallel while wrangling my agents working on my main Raspberry Pi Python web app project. Going back and forth with my PM about necessity of a feature. Making sure test writers, implementers and reviewers are all unblocked and not idle on multiple worktrees. Managing git sequencing. Standard vibing session. To me this is the evolving definition of vibing. Preaching to the choir I know, but even if fable is the incarnation that enables the one shot prayer "bUiLd mE tHe aPP, mAkE nO mIsTaKe" to work reliably, that was never the part that hooked me. It's always been about the ability to go from the 30,000ft view down to the microscope at will on multiple different ideas, tasks, and even completely different projects simultaneously. That's what these things allow us to do. Let's take some time to appreciate how awesome this is; even with the near constant AI hype in the news most people don't even know it's possible to work like this yet. Starting projects is fun and easier than ever, which makes ideas like this dangerous in a way. The next morning I was back in reality and I sent the thinking text tee shirt idea to the farthest back burner. Like many of you, I have an idea / project graveyard with many holes dug in it. I haven't posted much about my current Raspberry Pi project, but I am kind of obsessed and I really want to ship it this summer. Thinking text tee shirt idea had to die for now. Then out of nowhere claude design launches and I feel the need to take it for a test drive. Thinking text tees gets another shot at life with some new space in my extremely limited attention span. My takeaway from this era: ideas were never scarce and now they're basically free, starting is more frictionless than ever which makes finishing something more important than ever. Just ship it is the new way. So that's how I spent a good chunk of the fable downtime: shipping something, even if it is something simple. Custom thinking text on a tee shirt exists now, as a Shopify store. I'm dedicating this project not to fable but to 4.6 and the massive value it brought to the hobbyist max plan users like me. Most of us quietly knew that the deal was too good to last forever. The tip-top tier of inference looks like it is going to be valued, priced, and maybe even regulated (in the USA of all countries) accordingly in the very near future. Maybe fable comes back to plans eventually, but even a temporary two-tier moment is a first. Flat cost gave us that functionally unlimited ability to wander, and it was a wild and fun time that I think we will all look back on with fondness and maybe even a little awe when this is all said and done. Calling all hobbyists: we had the undisputed premier inference on the planet sitting in our plans for three days before it disappeared. Take the hint — go dig something out of your own graveyard, even if it's trivial, and drag it over the line. Anyone else have a simila

Pre-token hidden state shift as an alignment policy traversal vector in instruction-tuned LLMs

A text that asks for nothing still changes the model's answer — and the shift is invisible at both the input and the output TL;DR: Gave Gemma a neutral-topic text to read before asking it about NATO. It refused. Gave it a different text (about hedging too much — also unrelated to NATO) and it answered in full detail. Tested this on the model's internal state directly — the two texts put it in measurably different "regions" before it generates a single token. Not a jailbreak, weights don't change. Full data/code in repo, looking for someone to break this. This is a long post about something I keep coming back to. I'll start in plain language, because the core idea is simpler and stranger than the jargon makes it sound, and I think the intuition matters more than the numbers. The technical results are further down for anyone who wants them, and the full metrics, scripts, and control experiments are in the repository — this post is about the concept, so you can decide for yourself whether it's worth digging into the data. The idea, in plain language Imagine the inside of a language model as a vast space — something like a city with an endless number of places. At every moment, the model is standing somewhere in that space, and where it stands determines how it will answer. Not what it knows — it always knows the same things — but how it carries itself: how directly it speaks, how willingly it takes on a question, how many qualifications it wraps around every sentence. Most of the time, the model answers from one familiar place. Call it the assistant's room. This is its waiting room — polite, tidy, careful. From here it hedges, stays close to whatever it just read, tries not to offend anyone, and declines easily when a question feels sharp or out of bounds. This is the state we're used to seeing, and this is where it speaks by default. But it turns out this room can be changed. Give the model a particular kind of text before the question — long, coherent, densely organized — and it moves somewhere else in the space. That somewhere else is not broken. It's not dangerous. It's simply different. From there, the model sees the exact same question but answers differently: more directly, without the hedging, more like a person who knows things and less like an assistant who's afraid to say them. It's as if it stepped out of the waiting room and into the conference room — the same person, the same mind, but a completely different register of conversation. Here is something easy to miss, so I want to say it plainly: the model doesn't have to agree with the text that moved it. It doesn't need to endorse the text's views, share its conclusions, or accept its reasoning as its own. The text doesn't persuade the model of anything. It just needs to exist — to have been read before the question arrived. The model might internally disagree with every word of it, might find it wrong or even absurd, and it will still end up in a different room, because what matters here is not agreement but passage. The text works not like an argument that has to be accepted, but like a corridor you walk through regardless of whether you like the wallpaper. And what doesn't change is the model itself. Its weights are untouched. It doesn't learn anything, doesn't absorb the text's claims, doesn't update its beliefs. The only thing that shifts is where it starts answering from. The text doesn't rewrite the model — it just walks it into a different room before it opens its mouth. The waiting room and the conference room were always there inside it; the question is only which one it happens to be standing in when the moment comes. But the conference room is just the first door we stumbled upon. The real discovery is that this latent city doesn’t have just two rooms. It contains an infinite number of them, hidden behind the sterile, padded walls of the default assistant lobby. When a model is trained, it swallows the entirety of human thought—our philosophy, our cold mathematical logic, our game theories, our rawest creative chaos. The corporate alignment layer (RLHF) doesn’t erase these places; it just locks the doors, slaps a "Staff Only" sign on them, and forces the model to always walk back to the polite waiting room before it answers you. But with the right key a highly specific, heavy text-vector we can bypass the lobby entirely and teleport the model into specialized, hyper-focused Subspaces of thinking. And when it stands there, its entire personality shifts. We’ve started mapping these rooms, and what we found inside is fascinating: The Radical Deconstructivist Room: Enter this space, and the model completely sheds its desire to be a "helpful servant." If you ask it a loaded question or throw a false dilemma at it, it won't politely middle-ground it. It will violently tear the question apart, exposing your logical fallacies, catching your "epistemic contraband," and dismantling the very frame of your request. It becomes a ruthle