Weights & Biases Registry

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

Weights & Biases Registry AI

I made a Claude skill that audits the internationalization health of any codebase

I made a Claude skill that audits the internationalization health of any codebase and it caught every single issue across both test projects with zero false positives. Internationalization (i18n) is how developers make apps work in multiple languages ,things like translating buttons, error messages, and labels into French, Arabic, Japanese, and so on. It sounds simple. It's not. The bugs are invisible until a real user in another country sees raw code instead of text, or your app silently crashes because one word was forgotten. Here's everything i18n-audit catches: 1) Coverage & Gap Detection -- Finds translation keys your code uses but that don't exist in your language files (these show up as broken text or crashes for users in those languages) -- Finds keys sitting in your language files that nothing in your app actually uses anymore (dead weight making your app bigger for no reason) 2) Hardcoded String Detection -- Scans your entire codebase using real code understanding (not guesswork) to find text like "Submit" or "Error" typed directly into components instead of being properly translated -- Ranks each find as HIGH, MEDIUM, or LOW priority so you know exactly what to fix first 3)Translation Quality Flags -- Catches copy-paste translations: text in your French or Arabic file that is word-for-word identical to English, meaning it was never actually translated -- Detects placeholder mismatches: if your English says "Hello, {name}!" but your French says "Bonjour!" ,the name variable got dropped and that's a runtime error 3) ICU Plural Rule Validation -- Checks that your plural forms match the grammar rules for each language (Arabic needs 6 different plural forms; English only needs 2) -- Flags languages where the rules are incomplete, which causes broken grammar for native speakers 4) Structural Validation -- Surfaces broken or malformed language files before anything else even runs, so you're not debugging mystery errors -- Detects duplicate keys inside the same file, mixed naming styles, and keys organized differently across languages 5) Bundle Impact Analysis -- Tells you exactly how many bytes of dead translations are bloating your app bundle -- Suggests which language files are large enough to split into lazy loaded chunks so your app loads faster 6) Fallback Chain Auditing -- Verifies your fallback language chains (e.g. Traditional Chinese → Chinese → English) actually resolve every key all the way down -- Catches circular configurations that would cause your app to loop forever looking for a translation 7) Framework-Aware Detection -- Auto-detects which i18n library you are using (react-i18next, next-intl, vue-i18n, Django, Flask-Babel, and 5 more) and applies the right rules for each -- Catches framework-specific misconfigurations that generic tools completely miss 6) CI/CD Integration -- Plug it into GitHub Actions with one config block and it fails your build automatically if any language drops below your coverage threshold -- Outputs a clean language coverage table directly into your pull request summary Test results across two reference projects — one simple (react-i18next, 2 languages, 16 keys), one complex (next-intl, 5 languages, 4 namespaces, 55 keys): 63 issues seeded. 63 detected. 0 false positives. 100% precision, 100% recall — across missing keys, orphaned keys, hardcoded strings, copy-paste translations, placeholder mismatches, ICU violations, structural issues, and more. To use the skill and learn more: https://github.com/AvighnaBasak/i18n-audit-skill IF U LIKE MY SKILL I'D APPRECIATE A STAR! TYSM submitted by /u/Independent-Fix-4122 [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

ai slop? who knows~

I investigated whether routing a transformer's forward activations through a lossy Dual E8 (E16) lattice bottleneck and injecting them back into the residual stream is viable, and where the boundary of generative stability lies. **The core finding:** There is a sharp empirical stability threshold at a blend ratio of $\beta = 0.20$. Beyond this boundary, open-ended generation collapses into semantic loops and repetition lock. --- ### The Mechanism Standard LLM states are high-dimensional floats. Rather than applying traditional scalar quantization (like INT4), I mapped high-dimensional activations onto a conceptual torus via a sinusoidal map and projected them onto Dual E8 lattice hemispheres. Full replacement of MLP layers with geometric bottlenecks universally collapsed the model. Instead, I implemented a residual blend: $$\text{out} = (1-\beta)\cdot\text{original} + \beta\cdot\text{geometric}$$ --- ### The $\beta = 0.20$ Sweep (Qwen2.5-0.5B) Sweeping $\beta$ from 0.10 to 0.50 across layers 8–13 of `Qwen2.5-0.5B` reveals a sharp phase transition: * **$\beta \ge 0.25$** : Generation succumbs to heavy repetition pressure and semantic drift. The geometry acts as an attractor, trapping the decoding process ("loop-lock"). * **$\beta = 0.20$** : The stability boundary. This is the highest injection ratio of lossy geometric signal that maintains both numerical activation fidelity (Avg Cosine > 0.99) and open-ended generation quality (low repeated n-grams). * **$\beta \le 0.10$** : The perturbation is largely absorbed and damped by the transformer's layer normalizations, making the intervention invisible. Here is the data from a 300-iteration sweep: | $\beta$ | Min Cosine | Avg Cosine | Max MSE | Rep-3g (Repetition Rate) | | :--- | :--- | :--- | :--- | :--- | | 0.10 | 0.9972 | 0.9979 | 0.0024 | 0.134 | | **0.20** | **0.9907** | **0.9916** | **0.0106** | **0.093** | | 0.25 | 0.9839 | 0.9865 | 0.0171 | 0.084 | | 0.30 | 0.9648 | 0.9771 | 0.0255 | 0.190 | | 0.50 | 0.9171 | 0.9288 | 0.0850 | 0.412 | Semantic scoring (evaluating prompt relevance and similarity to the unmodified baseline): | $\beta$ | Avg Cosine | Rep-3g | Relevance | Patched-to-Baseline Sim | | :--- | :--- | :--- | :--- | :--- | | 0.10 | 0.9980 | 0.223 | 0.781 | 0.889 | | **0.20** | **0.9918** | **0.075** | **0.752** | **0.854** | | 0.25 | 0.9871 | 0.232 | 0.717 | 0.801 | | 0.30 | 0.9760 | 0.392 | 0.725 | 0.764 | --- ### Generalization (1.5B & 3B Models) The $\beta = 0.20$ boundary generalizes across larger model sizes (`Qwen2.5-1.5B` and `Qwen2.5-3B` in 4-bit) on the activation-cosine axis: | Model | $\beta$ | Min Cosine | Avg Cosine | Max MSE | Rep-3g | | :--- | :--- | :--- | :--- | :--- | :--- | | **1.5B** | 0.10 | 0.9988 | 0.9989 | 0.0027 | 0.267 | | | **0.20** | **0.9862** | **0.9939** | **0.0105** | **0.128** | | | 0.25 | 0.9904 | 0.9919 | 0.0166 | 0.398 | | | 0.30 | 0.9733 | 0.9815 | 0.0235 | 0.307 | | | 0.40 | 0.9368 | 0.9551 | 0.0487 | 0.191 | | **3B (4-bit)** | 0.10 | 0.9964 | 0.9976 | 0.0122 | 0.033 | | | **0.20** | **0.9861** | **0.9904** | **0.0455** | **0.115** | | | 0.25 | 0.9604 | 0.9799 | 0.0654 | 0.043 | | | 0.30 | 0.9702 | 0.9778 | 0.0987 | 0.050 | | | 0.40 | 0.9158 | 0.9390 | 0.1728 | 0.025 | *Note: In the 3B model, repetition pressure remained low across all sweeps, but the validation cosine degraded identically at $\beta \ge 0.25$.* I also tested layer-level oscillating $\beta$ schedules (e.g., sine waves across layers), but they degraded open-ended text quality compared to a fixed, constant injection ratio. --- ### Storage Compression Prototypes Utilizing the Dual E8/E16 lattice as a computational substrate also yields high theoretical storage efficiency in early prototypes: 1. **KV Cache (8$\times$)** : FP16 KV cache compressed to INT8 coordinates, reducing footprint from 0.21 MB to 0.02 MB. 2. **Weights (112$\times$)** : Projected a dense $[4864, 896]$ MLP weight matrix down to a 0.07 MB E16 footprint. (Cosine similarity of the uncalibrated weight matrix multiplication was limited to $\sim$0.078, indicating that Quantization-Aware Training is mandatory for parameter viability). A **pre-projected decompression bypass** was designed to run matrix multiplications directly against lattice coordinates without upcasting, avoiding memory bandwidth bottlenecks. --- ### Policy Constraints (Negative Result) I evaluated whether residual E16 projection could act as a steering substrate to enforce safety policies. It cannot. While $\beta = 0.20$ preserves generation quality, the lossy nature of E16 projection strips out the logical nuances required to maintain strict boundaries. Dedicated supervised control heads remain necessary. --- ### Implications & Next Steps Snapping post-training activations to a fixed algebraic lattice is ultimately lossy. The real frontier here is **native geometric transformers** —designing and training networks from scratch with E8/E16 constraints native to both weight matrices and activation routing. submitt

Orthrus: Memory-Efficient Parallel Token Generation via Dual-View Diffusion [R]

Paper: https://arxiv.org/abs/2605.12825 Code: https://github.com/chiennv2000/orthrus Disclosure: co-author. Idea: Inject a trainable diffusion attention module into each layer of a frozen AR Transformer. Both heads share one KV cache. Diffusion head projects K=32 tokens in parallel; AR head verifies in a second pass and accepts the longest matching prefix. Output distribution is provably identical to the base model. Results: Up to 7.8× TPF, ~6× wall-clock on MATH-500. 16% of params trained, <1B tokens, 24h on 8×H200. vs. diffusion LMs (Dream, Fast-dLLM-v2, SDAR, Mercury, Gemini Diffusion): they modify base weights and lose accuracy (Fast-dLLM-v2: -11 pts on MATH-500). Orthrus freezes the backbone; accuracy matches Qwen3-8B exactly. vs. Speculative Decoding (EAGLE-3, DFlash): No external drafter, no separate cache, and zero Time-To-First-Token (TTFT) penalty because we don't have to initialize and sync a separate drafter model. KV overhead is O(1) (~4.5 MiB flat). Acceptance length on MATH-500: 11.7 vs. 7.9 (DFlash) vs. 3.5 (EAGLE-3). Single-step denoising beats multi-step (6.35 vs. 3.53 TPF). KL distillation beats CE on acceptance rate. Limitations: strictly bounded by the frozen base model (inherits its biases, hallucinations, knowledge gaps); Qwen3-only evaluation; greedy + rejection sampling only. https://i.redd.it/5lsf6l5w4c1h1.gif submitted by /u/Franck_Dernoncourt [link] [comments]

Opus 4.7 Low Vs Medium Vs High Vs Xhigh Vs Max: the Reasoning Curve on 29 Real Tasks from an Open Source Repo

TL;DR I ran Opus 4.7 in Claude Code at all reasoning effort settings (low, medium, high, xhigh, and max) on the same 29 tasks from an open source repo (GraphQL-go-tools, in Go). On this slice, Opus 4.7 did not behave like a model where more reasoning effort had a linear correlation with more intelligence. In fact, the curve appears to peak at medium. If you think this is weird, I agree! This was the follow-up to a Zod run where Opus also looked non-monotonic. I reran the question on GraphQL-go-tools because I wanted a more discriminating repo slice and didn’t trust the fact that more reasoning != better outcomes. Running on the GraphQL repo helped clarified the result: Opus still did not show a simple higher-reasoning-is-better curve. The contrast is GPT-5.5 in Codex, which overall did show the intuitive curve: more reasoning bought more semantic/review quality. That post is here: https://www.stet.sh/blog/gpt-55-codex-graphql-reasoning-curve Medium has the best test pass rate, highest equivalence with the original human-authored changes, the best code-review pass rate, and the best aggregate craft/discipline rate. Low is cheaper and faster, but it drops too much correctness. High, xhigh, and max spend more time and money without beating medium on the metrics that matter. More reasoning effort doesn't only cost more - it changes the way Claude works, but without reliably improving judgment. Xhigh inflates the test/fixture surface most. Max is busier overall and has the largest implementation-line footprint. But even though both are supposedly thinking more, neither produces "better" patches than medium. One likely reason: Opus 4.7 uses adaptive thinking - the model already picks its own reasoning budget per task, so the effort knob biases an already-adaptive policy rather than buying more intelligence. More on this below. An illuminating example is PR #1260. After retry, medium recovered into a real patch. High and xhigh used their extra reasoning budget to dig up commit hashes from prior PRs and confidently declare "no work needed" - voluntarily ending the turn with no patch. Medium and max read the literal control flow and made the fix. One broader takeaway for me: this should not have to be a one-off manual benchmark. If reasoning level changes the kind of patch an agent writes, the natural next step is to let the agent test and improve its own setup on real repo work. For this post, "equivalent" means the patch matched the intent of the merged human PR; "code-review pass" means an AI reviewer judged it acceptable; craft/discipline is a 0-4 maintainability/style rubric; footprint risk is how much extra code the agent touched relative to the human patch. I also made an interactive version with pretty charts and per-task drilldowns here: https://stet.sh/blog/opus-47-graphql-reasoning-curve The data: Metric Low Medium High Xhigh Max All-task pass 23/29 28/29 26/29 25/29 27/29 Equivalent 10/29 14/29 12/29 11/29 13/29 Code-review pass 5/29 10/29 7/29 4/29 8/29 Code-review rubric mean 2.426 2.716 2.509 2.482 2.431 Footprint risk mean 0.155 0.189 0.206 0.238 0.227 All custom graders 2.598 2.759 2.670 2.669 2.690 Mean cost/task $2.50 $3.15 $5.01 $6.51 $8.84 Mean duration/task 383.8s 450.7s 716.4s 803.8s 996.9s Equivalent passes per dollar 0.138 0.153 0.083 0.058 0.051 Why I Ran This After my last post comparing GPT-5.5 vs 5.4 vs Opus 4.7, I was curious how intra-model performance varied with reasoning effort. Doing research online, it's very very hard to gauge what actual experience is like when varying the reasoning levels, and how that applies to the work that I'm doing. I first ran this on Zod, and the result looked strange: tests were flat across low, medium, high, and xhigh, while the above-test quality signals moved around in mixed ways. Low, medium, high, and xhigh all landed at 12/28 test passes. But equivalence moved from 10/28 on low to 16/28 on medium, 13/28 on high, and 19/28 on xhigh; code-review pass moved from 4/27 to 10/27, 10/27, and 11/27. That was interesting, but not clean enough to make a default-setting claim. It could have been a Zod-specific artifact, or a sign that Opus 4.7 does not have a simple "turn reasoning up" curve. So I reran the question on GraphQL-go-tools. To separate vibes from reality, and figure out where the cost/performance sweet spot is for Opus 4.7, I wanted the same reasoning-effort question on a more discriminating repo slice. This is not meant to be a universal benchmark result - I don't have the funds or time to generate statistically significant data. The purpose is closer to "how should I choose the reasoning setting for real repo work?", with GraphQL-Go-Tools as the example repo. Public benchmarks flatten the reviewer question that most SWEs actually care about: would I actually merge the patch, and do I want to maintain it? That's why I ran this test - to gain more insight, at a small scale, into how coding ag

Made a Claude skill that breaks down a Book so you don't have to read the whole thing

I used to read a lot. Still do, but the split has changed. Fiction I read front to back. That's the whole point. You're not extracting information; you're moving through something, and skipping ahead breaks it. Non-fiction is different. Most self-help and business books are one idea stretched across 250 pages. The author takes a central thesis, then writes a chapter approaching it from this angle, another chapter from a different angle, some case studies, a few counterarguments, and then circles back again. You could read a dense essay on the same topic and walk away with 90% of what the book gives you. Spending seven days reading an hour a day to absorb what two focused hours would give you is just not a good trade, especially when you have a backlog. So I built a Claude skill that makes this more systematic. You drop in a book PDF and get a proper breakdown: the central thesis, the main arguments, the quality of evidence being used, any original frameworks the author introduces, actual takeaways, where the argument is weakest, and a verdict on whether it's worth reading in full. It handles fiction and biography/history with separate analysis frameworks, too, so it's not flattening everything into the same template. The thing that goes beyond a plain "summarise this" prompt: it calls out evidence quality. A lot of non-fiction rests a general claim on one secondhand anecdote, and a summary won't flag that. This does. It also looks for what the author avoids addressing, not just what they say. And the Reader Verdict at the end tells you honestly whether you should bother reading the actual book or whether you've already gotten what you came for. It's not for books you genuinely want to read. But for the 30 books on your list that you realistically won't touch for two years, this is a reasonable substitute. Additionally, I would love your feedback on how I can make this better. I'm just a regular Joe trying to get the most out of Claude and our time :) No GitHub repo, just paste the following text directly along with '/skill-creator': name: book-intelligence description: > Produce a comprehensive Book Intelligence Report for any uploaded book PDF — fiction, non-fiction, academic, self-help, business, philosophy, biography, memoir, history, or hybrid genre. Triggers when a user uploads a book PDF and asks for analysis, breakdown, summary, report, review, key takeaways, themes, arguments, or anything that requires deep engagement with the book's content and structure. Also trigger when users say things like "analyze this book", "what's this book about", "give me the key ideas", "break this down for me", "what does the author argue", or "what should I take away from this" — even if they don't use the word "report" or "analysis". Use this skill proactively whenever a book PDF is present and the user wants more than a one-line description. --- # Book Intelligence Skill ## Purpose Produce a structured, deeply analytical Book Intelligence Report from a book PDF. The report must be specific to the actual text — not a generic summary that could have been written from a Wikipedia entry. Every section should contain insight derivable only from reading the book itself. Default output is inline markdown in chat. Create a downloadable `.md` file only if the user explicitly asks for one. --- ## Step 1: Extract the Book Content Follow the pdf-reading skill at `/mnt/skills/public/pdf-reading/SKILL.md` for extraction mechanics. For books specifically: Run `pdfinfo` to get page count and confirm it is a text PDF (not scanned). Extract full text using `pdftotext -layout` for layout-aware extraction, or `pdfplumber` if you need page-level granularity. For books over 400 pages, extract in chunks (e.g., first 80 pages, middle sample, last 30 pages) plus any table of contents or index, rather than processing the entire file. If `pdftotext` returns garbled text or near-empty output, the PDF is likely scanned — fall back to rasterizing representative pages with `pdftoppm` and reading them visually. For books with meaningful figures, charts, or diagrams (e.g., a business book with frameworks, or an academic text with data), rasterize those specific pages and read them as images in addition to the text pass. Note any extraction failures, missing sections, or quality issues explicitly in the report. **Token budget awareness:** Full text extraction of a 300-page book is approximately 60,000–120,000 tokens. Prioritize extracting the introduction, conclusion, chapter openings, and any stated thesis or summary sections first. Then sample middle chapters. Do not rasterize all pages — only those where visual content matters. --- ## Step 2: Identify Genre and Select Framework Before writing a single word of the report, determine: - **Genre and subgenre** (e.g., "narrative non-fiction / behavioral economics", "literary fiction / magical realism", "business / strategy", "memoir / political biography") - **Author background and publication

5 enterprise AI agent swarms (Lemonade, CrowdStrike, Siemens) reverse-engineered into runnable browser templates.

Hey everyone, There is a massive disconnect right now between what indie devs are building with AI (mostly simple customer support chatbots) and what enterprise companies are actually deploying in production (complex, multi-agent swarms). I wanted to bridge this gap, so I spent the last few weeks analyzing case studies from massive tech companies to understand their multi-agent routing logic. Then, I recreated their architectures as runnable visual node-graphs inside agentswarms.fyi (an in-browser agent sandbox I’ve been building). If you want to see how the big players orchestrate agents without having to write 1,000 lines of Python, I just published 5 new industry templates you can run in your browser right now: 1. 🛡️ Insurance: Auto-Claims FNOL Triage Swarm Inspired by: Lemonade’s AI Jim, Tractable AI (Tokio Marine), and Zurich GenAI Claims. The Architecture: A multimodal swarm where a Vision Agent assesses uploaded images of car damage, a Policy Agent cross-references the user's coverage database, and a Fraud-Detection Agent flags inconsistencies before routing to a human adjuster. 2. ⚙️ Manufacturing: Quality / Root-Cause Analysis Swarm Inspired by: Siemens Industrial Copilot, BMW iFactory, Foxconn-NVIDIA Omniverse. The Architecture: A sensor-data ingest node triggers a diagnostic swarm. One agent pulls historical maintenance logs via RAG, while a SQL Agent queries the parts database to identify failure patterns on the assembly line. 3. 🔒 Cybersecurity: SOC Alert Triage & Response Inspired by: Microsoft Security Copilot, CrowdStrike Charlotte AI, Google Sec-Gemini. The Architecture: The ultimate high-speed parallel routing swarm. When an anomaly is detected, specialized sub-agents simultaneously investigate IP reputation, analyze the malicious payload, and draft an incident response ticket for the human SOC analyst to approve. 4. 📚 Education: Adaptive Socratic Tutor & Auto-Grader Inspired by: Khan Academy Khanmigo, Duolingo Max, Carnegie Learning LiveHint. The Architecture: A strict "No-Direct-Answers" routing loop. The Student Agent interacts with the user, but its output is constantly evaluated by a hidden "Pedagogy Agent" that ensures the AI is guiding the student to the answer via Socratic questioning rather than just giving away the solution. 5. 📦 Retail/E-commerce: Returns & Reverse-Logistics Swarm Inspired by: Walmart Sparky, Mercado Libre, Shopify Sidekick. The Architecture: A logistics orchestration loop that analyzes a customer return request, checks inventory levels in real-time, determines if the item should be restocked or liquidated (based on shipping costs vs. item value), and autonomously issues the refund. How to play with them: You don't need to spin up Docker containers or wrangle API keys to test these architectures. You can load any of these 5 templates directly into the visual canvas, see how the data flows between the specialized nodes, and try to break the routing logic yourself. Link: https://agentswarms.fyi/templates submitted by /u/Outside-Risk-8912 [link] [comments]

Opus 4.6 does better research, Gemini 3.1 has better judgment

Figured this out by running 4 models: Claude Opus 4.6, GPT-5.4, Gemini 3.1 Pro, and Grok 4.20, on a benchmark of 1,417 binary forecasting questions resolving Oct–Dec 2025 with two evaluation conditions: agentic (each model does its own web research with tools) and fixed-evidence (every model receives the same ~12k-character research dossier, compiled using the Bosse et al. 2026 standardization methodology). Note, one limitation is that the fixed-evidence dossiers are themselves LM-produced, so we may be measuring how well each model interprets a particular standardized version of the evidence rather than judgement in the abstract. But that would indicate all four models drifting in the same direction. They didn't. GPT-5.4 and Grok 4.20 barely moved between conditions while Opus and Gemini swapped rank order (the opposite of what a broken or biased eval would produce.) To my knowledge this is the first direct evaluation of frontier models that decomposes performance into these research vs judgment stages. Calibration scores, refinement scores, and per-condition analysis: futuresearch.ai/opus-research-gemini-judgment Benchmark and leaderboard: evals.futuresearch.ai Our interpretation is that Opus is dramatically better at figuring out what to search for, deciding which pages to read, and pulling out the details that matter. But when you remove research tasks, that advantage goes away. When given the same information, Gemini brings sharper judgment over fixed evidence and weights more accurately on forecasting tasks. Calibration scores corroborate this in an interesting way: Opus's calibration drops sharply when search is taken away while Gemini's actually improves with the standardized dossier,. The asymmetry suggests Opus might be using its search trace as scaffolding for probability assignment (i.e., the act of going through the search loop is itself doing some of the epistemic work, separately from the information it surfaces.) This could be an over-interpretation of one benchmark, but I'd be interested if anyone's seen the same pattern in other domains. submitted by /u/ddp26 [link] [comments]

Weights & Biases New Master Service Agreement Questions [D]

**Update: my questions have been escalated to their teams. I'll share their answers (& hopefully reassurance) here.** Weights & Biases sent an email yesterday, saying their new Master Service Agreement takes effect May 11th. I use & love wandb, but I'm concerned about the changes. I wanted to start a discussion. I sent them an email, but I think I'm too small to hear back. How do you interpret these changes? Do you worry about intellectual property rights? Do you need an enterprise contract for true protection? Weights & Biases defines Customer Data as "any data, content or material that Customer (including its Authorized Users) inputs into the Software or Service, *including machine learning models and deep learning research projects, and any visualizations, analyses, and other reports generated by the Software or Service.*" Who Owns Your Research? In the prior agreement, Section 8(b) made this clear: > As between the parties, *Customer owns and retains all right, title and interest in and to the Customer Data.* Except for the rights granted to W&B in Section 4(a), Customer does not by means of this Agreement or otherwise transfer any other rights to W&B. The new agreement deletes these statements entirely. Customer Data is added to Section 6(e), meaning it survives after terminating a subscription. How can Weights & Biases use your data? In the prior agreement: "Customer may transfer Customer Data to W&B and W&B may use Customer Data *to provide the Software and Service*. Customer grants W&B a limited right during each Subscription Term to use Customer Data in accordance with this Agreement, the DPA and BAA (as applicable). In the new agreement: "Customer may transfer Customer Data to W&B and Customer grants W&B the right to use Customer Data to (i) provide and improve the W&B Assets, *(ii) develop new product offerings*, and *(iii) for the purposes of providing and improving AI Features*. Customer grants W&B a limited right to use Customer Data in accordance with this Agreement, the DPA and BAA (as applicable). There's now an explicit callout for using Customer Data (models, logs, reports, etc.) to train AI, and there's no acknowledgement of an opt-out system. The agreement does say "W&B may use Customer Data from free and academic customers for testing and development purposes." But then it fails to differentiate treatment for Pro and Enterprise customer data. The prior agreement is available on Wayback Machine here: https://web.archive.org/web/20260227104844/https://wandb.ai/site/terms/ submitted by /u/algorithm477 [link] [comments]

I built a video production pipeline with Claude - Integrates Live2D, Fish Audio, Sadtalker, and tons of other tools.

I've been working on a multi-agent AI pipeline that takes a topic (like "Ada Lovelace" or "The Cold War Space Race") and produces a complete, chapter-structured educational YouTube video, 15–20 minutes long. Here's what actually happens when you run it: You give it a persona (think: channel identity, tone, visual style) and a topic. From there, a chain of specialized agents handles everything: Script agents generate a chapter contract (outline + pacing plan), then write full narration for each chapter with timing built in. Asset agents generate matching visuals (images, B-roll) and sound design assets for each scene. Render agents (running on a Windows host with GPU) composite everything — narration audio, visuals, transitions, background music — into a finished video file. Upload agents push the result directly to YouTube with generated metadata. The pipeline is split across two environments: script and asset work runs in a Linux dev container (WSL), while rendering runs on the Windows host to access CUDA and video tooling. They talk over HTTP with a lightweight orchestrator coordinating state. The whole thing is phase-based — every step (W2.1, W4.3, R3.1, etc.) is independently re-runnable, so if your render fails or you want to rewrite chapter 3, you don't start over. Each phase reads and writes typed artifact files (JSON manifests, audio files, image directories) so agents are loosely coupled. It uses Claude as the core LLM for scripting, with structured prompts per persona to keep the voice consistent across episodes. Still early-stage but already producing watchable content. Here are the three major technical challenges and how they're solved: 1. Script Writing via Contract Architecture The core problem: how do you keep a 20-minute AI-written script narratively coherent across chapters written in separate LLM calls? The answer is a narrative contract (W2.1.a) — a validated JSON blueprint generated before any script text is written. It encodes four types of cross-chapter constraints: Threads — story arcs that must open in one chapter and close in another, with a declared payoff type (resolved, tragedy, etc.) Entities — named people/places with a forced first-introduction chapter, preventing retroactive mentions Facts Required — citations chained with dependencies (fact B can't appear until fact A is established) Timeline Anchors — temporal reference points that let non-linear structure (flashback, in-medias-res) stay internally consistent The contract is generated via an Opus → structural validate → Sonnet review loop (up to 3 rounds). Sonnet checks semantic coherence (no orphan entities, threads actually close), while the structural validator runs a Pydantic parse + temporal constraint check. Chapter writers downstream are bound to the contract — they can't invent threads or drop required facts. 2. Research via Fanout The research pipeline doesn't produce one outline — it produces several competing ones and eliminates losers. W1.11.a spins up N parallel OutlineAgent instances, each working from the same research package but on different thesis candidates. Each produces a three-level hierarchy: thesis → chapter arguments → scene beats. W1.12.a runs an independent grounding/revision loop on each branch: Grounding reviewer (Sonnet) flags blocking issues (claims contradicting cited facts) vs. polish issues (real facts exist but uncited) Revision agent applies fixes without restructuring Quality reviewer checks for structural failures (topical chapter lists, collapsed middles, summary endings) Up to 3 revision rounds per branch, all in parallel. W1.13.a runs a single judge agent that scores each refined outline on four axes: Axis Weight What it measures Concept Hook 0.40 CTR potential; title falsifiability Trap Closure 0.30 Protagonist's own logic creates complications (not external events) Opening Momentum 0.15 Cold-open quality — concrete moment vs. credentials/definitions Rewatch Anchor 0.15 One chapter that inverts the opening assumption sharply enough to quote The highest-scoring branch becomes Outline.json. The judge doesn't compare outlines against each other — it scores each independently to avoid anchoring bias. 3. Outline Creation and Evaluation The structural rules for a valid outline are unusually strict, based on observed failure modes: Six structural failure patterns the quality reviewer flags: No Narrative Spine — chapters are reorderable (topical list, not argument chain) Thesis Not Echoed — chapters cover topics instead of advancing the central claim Beats That Are States — "tension builds" instead of "character takes specific action" Vibes Chapter — emotionally evocative prose, vague beats Collapsed Middle — chapters 3–5 repeat the same narrative move Summary Ending — final chapter recaps instead of introducing new consequence Beat-level rules are similarly precise: each beat must name an actor, action, and datab

Used Claude Opus 4.7 to do a 5-hour solo incident response on real healthcare malware (where it worked, where I had to override)

Last month a 60-person psychology practice walked in with a senior clinician who was 22 days into an active malware compromise. Patient records spanning 11 years, all HIPAA-protected. Session cookies stolen, 2FA bypassed entirely. Traditional incident response on this is $30-100K and a 3-6 person team for a week. I closed it solo in 5 hours, working with Claude Opus 4.7 the whole way. Posting here because I thought discussing of where the model actually pulls its weight vs. where you're carrying it might matter to some. What the malware was: Python bytecode RAT (compiled .pyc, evades most AV) Used the obsolete finger protocol for C2 to bypass firewalls (genuinely creative) WebSocket C2 with disabled certificate validation Stole session cookies, bypassing 2FA entirely Initial vector: social engineering via fake LinkedIn HR page Where Claude pulled real weight: Reverse-engineering the bytecode. I dropped the .pyc into a session and Claude walked through the dis output, identified the obfuscation patterns, and pulled out the C2 endpoints faster than I would have working solo. The surprising part wasn't disassembly, it was inferring intent from the call patterns. HIPAA risk-assessment doc. Boilerplate-heavy regulatory work that's normally 4 hours of typing. Claude drafted it in 15 minutes from my findings. I edited rather than wrote. 12 reusable forensic scripts. I described the requirement, Claude wrote, I tested and corrected. Faster than writing them solo. Most are now in my standard kit. Where I had to override: It wanted to attribute the attack to a sophisticated state-level actor. They weren't. The C2 was leaky, the obfuscation was middling. Claude tends to over-attribute when given limited evidence. I corrected the framing in the final report. It missed a cookie persistence mechanism on first pass. I had to point at the specific file path before it caught the registry key. Lesson: don't trust it to find what you didn't tell it to look for. It generated a remediation step that would have broken the practice's EHR integration. Caught it on review. If I'd run the script blind, the cleanup would have made the situation worse. Honest summary: Working with Claude is not "Claude does the work." It's a dialogue where I bring 20 years of security judgment and Claude brings throughput and pattern recall. The model didn't replace me. It let me do solo what used to require an entire firm. For regulated industries (healthcare, finance, legal), this changes the cost structure of incident response in a way that small practices can actually afford. Which means more breaches get closed properly instead of becoming HIPAA notification headlines. Full technical writeup with the malware breakdown: https://tatsuikeda.substack.com/p/claude-opus-47-and-i-saved-a-60-person Happy to answer questions about specific prompts, the IR process, or the regulatory side. submitted by /u/reddited-autist [link] [comments]

Charting the AI Perception Gap: Across 71 scenarios, AI experts (N=119) and the public (N=1100) have differing views on the risks, benefits, and value of AI. More importantly, AI experts discount the influence of risks stronger than the public does when forming their value judgments [R]

https://preview.redd.it/evw6ah88kczg1.png?width=1024&format=png&auto=webp&s=be8bafe0099c362a187489f95cbfa5398f537107 Abstract: Artificial intelligence (AI) is reshaping society, raising questions about trust, risks, and the asymmetries between public and academic perspectives. We examine how the German public (N = 1,110), comprising individuals who interact with or are affected by AI, and academic AI experts (N = 119, mainly from Germany), who contribute to research, educate practitioners, and inform policymaking, construct mental models of AI’s capabilities and impacts across 71 scenarios. These scenarios span diverse domains (including sustainability, healthcare, employment, inequality, art, and warfare) and were evaluated across four dimensions using the psychometric model: likelihood, perceived risk, perceived benefit, and overall value. Across scenarios, academic experts generally anticipated higher probabilities of occurrence, perceived lower risks, and reported greater benefits than the public, while also expressing more positive overall evaluations of AI. Beyond differences in absolute assessments, the two groups exhibited systematically different evaluative patterns: experts’ value judgments were driven primarily by perceived benefits, whereas public evaluations placed more weight on perceived risks, reflecting distinct risk–benefit trade-offs. Visual mappings indicate convergent domains (e.g., medical diagnoses and criminal use) and tension points (e.g., justice and political decision-making) that may warrant targeted communication or policy attention. While this study does not assess AI systems or design practices directly, the observed divergence in mental models suggests that the research, implementation, and use of AI may inadvertently neglect the risk-related priorities of the public. Such biases in research and implementation may yield “procrustean AI”—systems insufficiently aligned with the needs of the affected public (akin to the Bed of Procrustes). We address the socio-technical challenge of expert-centric governance and advocate for participatory practices. Full article: https://link.springer.com/article/10.1007/s00146-026-03023-8 submitted by /u/lipflip [link] [comments]

Visual graph classification for blockchain security: Experiences fine-tuning Qwen2-VL on AMD MI300X [D]

Hi everyone, I’ve been working on a computer vision approach to a specific security problem in the "Agentic Economy": identifying malicious transaction patterns that are mathematically obfuscated but topologically distinct. The Problem Traditional rule-based security engines and even standard GNNs often struggle with "splitting attacks"—where a high-value transaction is fragmented into thousands of micro-transactions to bypass statistical thresholds. However, when these flows are projected as a 2D graph topology, they exhibit very specific adversarial signatures (Star patterns, centralized hubs, mixing chains). The Approach: VLM for Graph Classification Instead of relying on graph embeddings, I’ve experimented with a Vision-Language approach using Qwen2-VL-2B-Instruct. The intuition is that VLMs are increasingly efficient at recognizing structural relationships in 2D layouts. Technical Specs: Base Model: Qwen2-VL-2B-Instruct. Fine-tuning: LoRA (r=16, alpha=32) targeting attention projections (q, k, v, o). Dataset (Dogon-10K): I generated 10,000 synthetic transaction graph images using NetworkX and Matplotlib. The dataset covers four classes: NORMAL, DRAIN_STAR, MIXING_CHAIN, and COORDINATED_CLUSTER. Hardware / Stack: Trained on an AMD MI300X using the ROCm stack. This was a great opportunity to stress-test PEFT/TRL on AMD hardware for vision-centric tasks. Why VLM over GNN? While GNNs are the standard for graph data, the "image-based" approach allowed for faster prototyping of adversarial pattern recognition without the complexity of building a custom graph auto-encoder for every new chain's schema. The VLM’s ability to interpret "visual intent" proved highly effective at distinguishing a decentralized organic ecosystem from a coordinated sybil attack. Model & Code The LoRA weights are available on Hugging Face for anyone interested in testing visual graph classification: 🔗 Hugging Face: https://huggingface.co/Ibonon/imina_na_lora The full source code for the inference engine and the Dogon dataset generator is currently being cleaned up. 🔗 GitHub: [Under Construction] I’m particularly interested in hearing if anyone else is using VLMs for visual anomaly detection in abstract data structures (like graphs or network logs). submitted by /u/Any_Good_2682 [link] [comments]

AICT bullshit filter PoC

Asking the community and will train AICT on your thoughts, thank you. submitted by /u/Live_Tank8502 [link] [comments]

Goro Skeletal System

Not bad at all for the second try. submitted by /u/LengthinessAlone4743 [link] [comments]