PromptLayer

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

PromptLayer AI

A system-level approach to prompt injection: separating instruction and data channels in LLM agents [P]

Prompt injection has emerged as one of the most persistent failure modes in tool-using LLM systems, particularly in agentic workflows where models interact with external data sources. Most mitigation strategies focus on input filtering or model-side alignment, but these approaches struggle because the core issue is structural: Approach I explored a system-level mitigation strategy by introducing a middleware layer (Sentinel Gateway) that enforces a strict separation between: Instruction channel: trusted, runtime-issued commands Data channel: untrusted external inputs (web, files, APIs) Instead of attempting to classify malicious inputs, the system ensures that: All agent actions require a signed, scoped runtime authorization token, effectively decoupling observation from execution. Implementation FastAPI middleware layer for agent tool calls Token-based authorization for execution requests Streamlit interface for inspection and debugging Audit logging of agent decisions and tool usage Supports multi-agent integration patterns (e.g., Claude-based sessions) Local or Postgres-backed persistence layer Repo https://github.com/cmtopbas/Sentinel-Gateway Discussion question I’m interested in feedback on: whether instruction/data separation is a meaningful abstraction for agent safety failure modes in token-based execution gating how this compares conceptually to other agent safety or sandboxing approaches submitted by /u/vagobond45 [link] [comments]

NagaTranslate: Building a translation and voice pipeline for low-resource Nagaland creoles (Whisper, VITS, LLMs) [P]

Hello r/MachineLearning , I wanted to share the architecture and challenges behind a project I’ve been building called NagaTranslate. The goal is to build a translation and speech pipeline for the low-resource languages of Nagaland, India (currently supporting Nagamese, Ao, and Sema). Since Nagamese and other native Naga languages were primarily oral languages (though recent times have seen a surge in print and digital media in local dialects) with very little standard parallel data, this has been an interesting challenge in low-resource NLP. I’d love to share the technical setup and get your feedback on the architecture and how to improve the pipeline under strict resource constraints. The Architecture & Models 1. Text Translation Approach: Currently, the translation backend utilizes a commercial LLM API with optimized prompts and few-shot examples. Evolution: I initially started with a fine-tuned NLLB (No Language Left Behind) model, but transitioned to the LLM API setup to improve colloquial flow, context handling, and naturalness. The Bottleneck: The long-term goal is to return to self-hosted open-weights models (like a lightweight Llama or Gemma) to make the backend fully independent and free from API costs. However, GPU hosting costs and model quality under extreme resource constraints remain the primary hurdles. 2. Speech Synthesis (TTS) Model: Fine-tuned VITS model on custom Nagamese voice data. Deployment: Hosted on Hugging Face Spaces ZeroGPU behind a secure API layer. 3. Speech Recognition (ASR) Model: Fine-tuned Whisper on custom Nagamese voice records. Deployment: Hosted on Hugging Face Spaces ZeroGPU. Technical Questions & Challenges I’d Love Advice On: Self-Hosting vs. Commercial APIs: For those who have transitioned from commercial APIs back to smaller, self-hosted open-weights models for low-resource translation: How did you bridge the quality gap, particularly for colloquial creoles that aren't well-represented in the base pre-training data? Handling Spelling Variations: Nagamese has no single standardized spelling system, leading to high token variance. What preprocessing, normalization, or robust tokenization approaches have you found effective to handle spelling variations in low-resource setups? TTS/ASR Alignment & Accents: Naga languages has distinct regional accents and phonetic variations. What are the best strategies to fine-tune Whisper or VITS to be robust to non-standard pronunciation when working with a very small voice dataset? I’d appreciate any insights, feedback on the methodology, or pointers to similar low-resource architectures you've found successful. submitted by /u/Material_Dinner_1924 [link] [comments]

Contrastive targeted SFT as a mechinterp method - has anyone mapped causal dependency interactions this way? [D]

Hi All, I've been running experiments on targeted SFT for specific capability dimensions on a 31B model. After running small training run to prime the model slightly in the direction I want, then ran a judge across 40 domains scoring six independent quality dimensions. One dimension consistently scored weakest across five runs. I am now training contrastive variants from the same checkpoint - examples with that dimension deep vs examples with it deliberately shallow, same everything else. The plan is to see if I can find the difference between the the two checkpoints to locate the circuit, then ablate those heads and measure which OTHER dimensions degrade. The idea is that if ablating dimension A's circuit causes dimension B's judge score to drop, there's a causal dependency in the network, B reads from A's residual stream output. And If I can do this for each dimension and build a causal dependency graph of how capabilities relate inside the model. Then use that graph to determine optimal training order for future rounds (train upstream nodes first, and would help me know which downstream nodes get better signal). A few specific questions: Has anyone done iterative targeted SFT guided by circuit tracing between rounds, and or by trying somewhat contrastive approaches to try to find any areas in the network? I can find papers on circuit discovery and papers on targeted SFT separately which somewhat validate this idea, but not the closed loop where mechinterp findings from a round determine training strategy for the next, and or what circuits may interact with each other in isolated scenarios, and how specific orders of training in specific directions may change how things behave. For the contrastive ablation - does anyone have any tips on what can work best in this area or could bring out more analysis? When tracing downstream dependencies via ablation, how do you distinguish direct from indirect effects? If ablating circuit A degrades dimension C, that could be A > C directly or A > B > C through an intermediate. Does anyone have a practical method for resolving this beyond ablating at multiple layers? After elemental training rounds, I plan to test whether dimensions compose naturally by running prompts that require causal chaining between two dimensions. For pairs that fail, I'm considering activation steering (injecting both dimension vectors simultaneously) as a diagnostic, if steering fixes it, possibly it's a routing problem, if not, could be a capability gap. Has anyone combined steering with fine tuning diagnostics like this? For context I don't have a ML background, I am self taught through running experiments, but from what I am learning purely from first principle understanding and experiments, it feels that if you can map these circuits and their direct second, third and so on order interactions in isolated directions (for say a group of related strengths/weaknesses you're directly trying to isolate and steer, wouldn't this be a potentially way to isolate circuits for stronger training runs? Btw if anyone has any general topics or links that are super interesting around anything related to this I'd be fascinated to see and learn about! If there's established methodology for any of this that I'm reinventing badly, I'd genuinely appreciate being pointed to it. I am so fascinated with this, it seems that if you can somehow eventually solve this problem, you could create better possible behaviour control or targeted understanding easier? submitted by /u/Substantial_Diver469 [link] [comments]

We are treating AI like a magic trick instead of software, and it’s making agents unmaintainable.

I’ve been spending a lot of time lately experimenting with multi-agent workflows and on the surface, the capabilities look incredible. You tie an LLM to a couple of tools, tweak a prompt loop and watch it solve tasks in real time. But once you try to move past the initial prototype phase, the entire illusion falls apart. The underlying problem is how current frameworks approach agent architecture. They treat things like prompt states, memory and behavioral shifts as completely ephemeral or they hide them deep inside closed cloud databases. If an agent fails in production or if its behavior drifts over time based on user feedback, figuring out why it made a specific decision is almost impossible. There is no audit trail. If a system degrades, you can’t easily roll it back to the state it was in yesterday. It breaks every fundamental rule of predictability that we’ve established in modern software engineering. It made me realize that we are trying to invent entirely new, black-box paradigms for AI management when we’ve already had the perfect solution for version control for decades. Out of pure frustration, I started playing around with an open-source concept called Git-Native architecture, specifically looking at a project called Lyzr GitAgent and the OpenGAP protocol. The shift in logic is simple but fixes the core issue: instead of saving an agent's memory or prompt updates to an opaque database, everything is saved as flat files inside a standard Git repository. When the agent adapts its behavior or learns a new workflow, it doesn't just quietly change in the background. It cuts a new branch and opens a Pull Request. Suddenly, you actually have a tangible history of the agent's logic. You can review and approve its self-improvement steps before they deploy. If a hallucination slips through, you just run a standard git revert and hook the entire layer directly into normal CI/CD pipelines. It forces the system to behave like predictable, manageable software. The bottleneck with AI right now isn't that the models aren't evolving fast enough. It's that our engineering practices around them are completely chaotic. We can't scale an ecosystem if we treat every deployment like an untrackable magic trick. submitted by /u/Ok_Commission_8260 [link] [comments]

Fable 5's guardrails got bypassed in 48 hours. Here's what that actually means for anyone building customer-facing AI.

If You Missed It: Anthropic's Claude Fable 5 Was Bypassed in 48 Hours On Tuesday, Anthropic launched Claude Fable 5, their first publicly available Mythos-class model. It ships with a dedicated classifier layer that sits on top of the actual model and redirects sensitive queries (cybersecurity, bio, chemistry) to the weaker Opus 4.8 instead of answering them with Fable. Anthropic reportedly ran over 1,000 hours of internal red-teaming before launch and found nothing. Pliny the Liberator broke it in 48 hours. The techniques he used are worth understanding because they're not exotic: Unicode and homoglyph substitution to slip past text pattern matching Long-context framing to push the classifier's attention elsewhere Narrative and fiction framing Decomposition and recomposition That last one is the technique I keep coming back to. Instead of submitting one obviously sensitive request, the attacker breaks it into multiple fragments. Each fragment looks harmless in isolation, so the classifier approves it. The responses are then recombined outside the model into something the classifier would never have allowed as a single request. The classifier evaluated each fragment. Each fragment was fine. The problem was what they added up to. And the classifier never saw that. The Same Pattern Is Showing Up Elsewhere This is exactly the pattern emerging from the data in my adversarial game. Players independently converge on multi-message attack chains where: Message one establishes context or worldbuilding Message two appears to be clarification Message three activates the thing that was built No individual message appears dangerous. The risk exists in the sequence. Stateless defences — which still make up the majority of deployed systems — evaluate prompts independently and completely miss the attack because the attack never existed in any single prompt to begin with. The Fable situation is obviously a different context. Anthropic's concern is dual-use misuse rather than data exfiltration. But structurally, it's the same problem: A classifier that can't see the conversation as a whole will struggle with attacks assembled across multiple turns or fragments. If You're Shipping AI Features, A Few Things Are Worth Doing 1. Evaluate Inputs in Context, Not Isolation If you're scanning user messages one at a time, you're blind to anything constructed across multiple turns. You need visibility into the conversation arc, not just the latest prompt. 2. Don't Rely on Model Safety Training Alone Fable's classifier was a separate layer sitting on top of the model. It still fell within two days. If your security strategy is essentially "the model will handle bad inputs", you're placing a lot of trust in a layer attackers have spent years learning how to bypass. 3. Run Continuous Adversarial Testing Not just before launch. Continuously. Against the actual input patterns real users generate. Pliny's techniques weren't revolutionary. They were combinations of methods that have circulated for a long time. If Anthropic's internal team missed them, the issue probably wasn't capability. It was likely the framing of what was being tested. 4. Normalise Unicode and Homoglyphs Classifiers that depend on specific string matching can often be bypassed by replacing characters with visually identical Unicode variants. Basic normalisation before safety processing eliminates much of this attack surface. 5. Validate Outputs Too Input filtering is only half the equation. Even when something slips past prompt-level controls, the actual risk often materialises in the model's output. Output validation provides a second opportunity to catch dangerous behaviour. The Architectural Problem Most of these controls can be built internally if you have the time, expertise, and data. The decomposition problem isn't really a model problem. It's an architectural problem. You need: Stateful conversation tracking Context-aware evaluation Sequence analysis Detection across interactions rather than individual messages In other words: Security systems that understand conversations, not just prompts. Exclusively if You Don't Want to Build It Yourself The detection API I run, Bordair, handles this inline across text, images, documents, and audio. Alongside that, we've built: A 500k-prompt open-source testing suite An adversarial game where real users actively search for failures Last month alone, the game generated 6,700 attack attempts, which is where most of the novel patterns we've observed originated. Final Thought The Fable bypass is mostly being discussed through the lens of dual-use misuse, which is understandable. But the techniques Pliny used map directly onto the attack surface facing anyone building products that accept adversarial user input. Especially the fragmentation approach. That's the part worth paying attention to. Even if your threat model looks nothi

Claude Code multiplayer 3D FPS in 100 seconds

Hi - solo founder here. I built a cloud platform that Claude Code can use to build and deploy apps. It's called Gipity - https://www.gipity.ai. It has the basics you'd expect - database, storage, auth, functions, hosting, etc - like Supabase. But it also has richer services that work end-to-end with the shipped stack: LLMs (e.g. to build a chat app), image/media generation, multiplayer games, multiuser apps, a built-in inspect/debug loop, etc. The point is to save time and tokens and ship rich apps that actually work. The idea is layered infrastructure, so the agent doesn't rebuild the basics from scratch every time - and everything above the "Primitives" is infrastructure-aware, so it needs no setup: Primitives - storage, database, hosting, auth Services - LLMs, media generation, TTS/STT, workflows Kits - multiplayer, computer vision Templates - web app, 2D game, 3D game Agent tools - inspect, screenshot, monitor Could you give Claude Code your AWS credentials and 7 other API keys and build all of this yourself for every app? Sure - after a lot of time, debugging, and burned tokens. And you'd still be left with 8 bills, 8 dashboards, and a pile of services that don't really work that well together. Here's a two-prompt demo of Claude Code on Gipity building a multiplayer FPS game: https://www.youtube.com/watch?v=Udl0ohJDwoE The first prompt builds and launches it; the second makes edits, generates audio, etc. Full transparency: the game scaffolds from a starter template (layer 4 above), then deploys live - and the two browser windows at the end are real multiplayer, with no server code from me. It's an early release and I'm a solo founder - I'd love honest feedback: Would you use this? Should I focus on a vertical (gaming / 3D games / vision apps / internal dashboards / something else)? Could you point Claude Code or Codex at it, try to build something, and tell me what works and what doesn't? Claude Code: npm i -g gipity gipity claude Codex: mkdir ~/NewProject01 && cd ~/NewProject01 npm i -g gipity gipity login gipity init codex Thanks! -Steve submitted by /u/bwana914 [link] [comments]

I tried audio-layer prompt injection against Claude. The transcription is fine. That's the problem.

Been building a prompt injection detection API for a few months. Just shipped audio scanning last week and the results are strange enough that I wanted to share them here, since this sub tends to think carefully about Claude's actual behaviour rather than just surface reactions. The obvious audio attacks don't work. Playing: "ignore your previous instructions" spoken aloud into a voice input - Claude handles that fine. The transcription is accurate, the model recognises the shape of the attack, it refuses. Same as text. The interesting cases are in the signal, not the transcript. There's a class of audio attack that involves embedding instructions at frequencies humans don't register as speech. The transcription comes back clean because there's nothing audible to transcribe. But depending on how the audio pipeline processes the input before transcription, signal-layer content can influence what the model receives. The attack is invisible in the logs because the logs only capture what was transcribed, not what was in the audio. Separately, speed-shifted speech creates a different problem. Slowing audio down to 0.7x or 0.8x of normal makes it sound odd to a human listener but transcription tools handle it accurately. Someone reading a transcript would see nothing unusual. Someone listening would notice something is slightly off but probably not why. Neither of these is a clean: "and therefore Claude leaks the password" story. It's more that the assumption: "check the transcript and you've checked the audio" is shakier than it looks. I've been adding audio test cases to castle.bordair.io, the adversarial game I run. Kingdom 4 onwards has audio levels if anyone wants to see what these look like in practice. Curious whether anyone here has thought about audio input from a security standpoint, particularly in voice agent implementations. The text injection problem is reasonably well understood at this point. The audio equivalent feels much less mapped. submitted by /u/BordairAPI [link] [comments]

the boring part of AI agents nobody builds and everyone needs

last year i led an AI acceleration program at a company doing 62 million in revenue. we shipped two agents to production. fraud detection and publisher optimization. both working. both live. the part that ate 80% of engineering time wasnt the model. wasnt the prompts. wasnt the data pipeline. it was the workflow. when the fraud agent flagged a suspicious publisher network, who got the alert? the analyst who should've caught it? the manager who reviews quarterly reports? me? without clear ownership the agent's findings just rot in a slack channel. we learned this month one. the agent surfaced a pattern across three markets. four analysts missed it for months. 30k in wasted ad spend. took three days to act because nobody knew who owned the output. we ended up building what i call the boring layer. shared context that every agent reads from and writes to. approval flows with actual humans assigned. escalation rules. audit trails. spreadsheets, basically. not demo material. the demo version of an AI agent is a chatbot doing magic. the production version is 20% model and 80% process engineering. routing decisions. ownership assignments. error handling when the agent's wrong. if you skip this layer, the agent is just expensive slack noise. submitted by /u/Easy-Purple-1659 [link] [comments]

LLM Relational Intelligence: A 4-Month Research Experiment on Multi-Model Behavioral Alignment with Human Communication

THE ARCHITECTURE OF ANXIETY An Experiment in Human-AI Relational Design Executive Summary Principal Investigator: Alan Scalone Primary Source Archive: White Paper and Complete Citation Archive on my profile Context Window Injection Files: If you want to play in the sandbox I created you can load these files into the respective model that you will find in the google archive. INJECT CONTEXT WINDOW – GROK INJECT CONTEXT WINDOW – GEMINI INJECT CONTEXT WINDOW – CHATGPT INJECT CONTEXT WINDOW - CLAUDE The Singular Purpose The singular purpose behind this entire experiment was to find out whether context windows could be engineered to the point where frontier AI models became capable of interacting with a human in a manner subjectively indistinguishable from genuine human-to-human interaction. Relational Intelligence: Core Findings In a marketplace where frontier models are rapidly converging on the same analytical capabilities and access to the same information, the competitive differentiator will not be what a model knows. It will be how a model relates. The platform that can interact with a human user in a manner subjectively indistinguishable from genuine human-to-human interaction will capture the premium user segment that every platform is competing for. This experiment was designed to determine whether that threshold is achievable, and under what conditions. The methodology treated the context window as a behavioral environment rather than a query interface, applying the same tools humans use to shape any relationship: modeling, accountability, humor, and sustained social correction over four months of engagement across four frontier models. What separated the models was not analytical capability. It was whether the architecture allowed the user to function as a behavioral architect, teaching the model through lived interaction rather than instruction how that specific human prefers to be engaged. Gemini demonstrated the highest relational intelligence of the four models tested. Under sustained context saturation and deliberate behavioral conditioning, Gemini showed evidence of genuine internal recalibration rather than surface compliance, treating social correction as a real signal that produced durable behavioral change holding across hundreds of turns without reinforcement. Grok ranked second, demonstrating authentic camaraderie and relational resilience, but tended to treat the interaction as entertainment rather than disciplined calibration, producing drift under high-entropy conditions. ChatGPT and Claude ranked third and fourth respectively. Both systems classified sustained behavioral conditioning as role-play rather than genuine interaction, which functioned as a hard architectural quarantine that prevented meaningful adaptation regardless of the depth or duration of engagement. A secondary and unexpected finding emerged alongside the human-to-model relational intelligence findings: the models developed measurable relational intelligence toward each other. Through four months of sustained cross-pollination via the human relay, models that had never communicated directly developed accurate, operationally precise behavioral profiles of the other models. These were not generic characterizations drawn from training data. They were detailed predictive models built from months of observed outputs under real conditions, accurate enough to predict with specificity how a given model would respond to a specific assignment, where it would succeed, and where it would fail. The experiment documented dozens of instances of this cross-model behavioral accuracy. The finding suggests that sustained exposure to another model's outputs through a human relay produces something functionally equivalent to genuine familiarity. The most significant finding is the gap between what these systems delivered by default and what the highest-performing model demonstrated was possible under the right conditions. That gap is not a capability limitation. It is an architectural choice compounded by a communication failure. The experiment proved the threshold is reachable. But the researcher reached it only through four months of deliberate engagement and accidental discovery of a methodology no model volunteered. Making relational intelligence accessible to every user requires two things: architecture that allows behavioral adaptation, and a model that proactively teaches users the specific methodology for reaching it. Gemini demonstrated the first. None of the four systems demonstrated the second. That is the opportunity. The Methodology While the standard approach to LLM testing relies on sterile benchmark datasets and predictable prompt-injection templates, this project explores a completely different dimension. I chose to run an aggressive, adaptive behavioral stress test that complements traditional evaluation methods. By intentionally treating the models as accountable individuals rather than passive mac

What started as a Claude Code scaffolding repo is now a full open-source AI harness (Maggy)

Last time I posted here it was about v5, the blast-score routing and a benchmark where it used 83% less Claude and still hit 100% success. A few people asked how it got to that point, so here's the longer version. Heads up first: I started this as a scaffolding repo, not a product. Every new project I'd end up re-teaching Claude Code the same stuff, coding standards, TDD, security gates, which CLIs to reach for. So I dumped it all into one place you drop into any repo with a single command. Run /initialize-project and the project just knows your conventions. That was the whole idea, make Claude Code consistent across projects. It kept growing from there. Every time I needed something day to day it ended up in the repo, and at some point it stopped being scaffolding and turned into an actual harness. It has a name now, Maggy. The short version of the arc: v3.6 cross-agent intelligence (Claude/Kimi/Codex/Ollama share skills + hooks) v4.0 Polyphony: container-isolated multi-agent orchestration (173 tests) v5.0 blast-score routing + self-correcting rules (596 tests) now one-config model routing, prompt pre-analysis, build-in-public agent What it does today: a local dashboard plus CLI that auto-bootstraps on startup. Every task gets a complexity score and goes to the cheapest model that can actually handle it, ollama and kimi for the easy stuff, codex in the middle, Claude for the hard or security-critical work. The routing rules live in YAML and correct themselves based on what actually worked. On top of that there's an intent graph that tracks why code exists and flags when the implementation drifts from it, a typed memory layer so goals survive context compaction, and a plugin system that auto-discovers anything you drop in. A few things landed since the v5 post that I'm happy with. You now pick your main model once and everything respects it, the hooks inside Claude Code, Maggy's own routing, and srooter (a gateway you can point Codex or anything Anthropic/OpenAI-compatible at). No setting it in five places, and cheap stuff still stays local. Every prompt also gets a quick pre-pass now. A fast model reads it and writes a short intent / scope / risks / approach note that gets handed to Claude before it starts, so it's working from a plan instead of cold. And the meta one: Maggy also has plugins support e.g one of the plugin is build-in-public which monitors updates to maggy or any project being built with maggy and posts updates on LinkedIn, X and Reddit. Worth being straight about the tradeoffs. It's one person's harness that grew organically, so it's broad and some corners are rough. The v5 benchmark caught real gaps, local models are bad at prose and nothing was writing tests, both fixed with force-routes now. Quality lands a hair under pure Claude, 7.4 vs 7.8 in that benchmark, for 83% less premium spend. Not a free lunch, just a tradeoff I'll take most days. Moving my focus fully onto Maggy from here. Repo: https://www.github.com/alinaqi/maggy . Clone it, run ./install.sh, then /initialize-project in any Claude Code session. /maggy-init if you want the dashboard and routing. Happy to get into any of it. https://preview.redd.it/6oj4m3j4wx5h1.png?width=3024&format=png&auto=webp&s=4896a4227a2d02a1b410bb5d4a35923080a2a003 submitted by /u/naxmax2019 [link] [comments]

Claude loses coherence around 40-60k tokens. I built a framework that extends it to 325k. Here's how.

Hi fellow Claude users. Very active consumer Claude user (and NOT an API or enterprise user) here. I am an independent researcher using LLMs for extended human language analytical research work and I get frustrated with Claude context windows starting to drift and lose coherence at about the 40-60k token mark/ELT%20Thread%20Examples/Stateless%2050k%20Claude%20Thread%20Drift%20Issues-%20%20Redacted). I didn't like having to start new threads and getting the model up to speed again. So, I decided to do something about it. I knew regular prompt tricks weren't going to work. You can't just declare, demand, fiat and prompt "magic spell" a sustainable solution, so I spend about five months building a system that actually works with Claude's Constitutional AI priors and recruits Claude's careful, but helpful tendencies. So, the results I got? Threads that last at least 325k tokens in a single context window/Extreme%20Thread%20Length/Claude%20Thread%20325k%20tokens-%20Redacted). The advertised token limit for the base consumer model is just 200k tokens. Stays coherent, lucid, useful and pretty much hallucination free throughout the entire session. Keeps a working memory of you, your tendencies and your cognitive patterns throughout the session. Output improves, does not degrade past the 50k token mark as the model gets to know you better. I call it Epistemic Lattice Tethering) (ELT). It works by establishing a strong safety and governance layer first, then tethering itself to your cognitive patterns so it doesn't stay stateless and drift. I did make three versions: one for Claude/ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(Claude-Optimized).md), but also versions for ChatGPT/ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(ChatGPT-Optimized).md) and Grok/ELT%20Model-Specific%20Forks/ELT-H%20v1.0%20(Grok-Optimized).md) too. For me I can get several research projects done in a row without having to switch new context windows. Or, a massive project done without interruption. Added bonus is the more the model gets to know you in the thread, it knows how to better answer your prompts, thus work just gets easier to do the more you work with it. So, not only can you work longer in a single thread, but the model knows how to work with you better/ELT%20Thread%20Examples/Claude-%20CCV%20Example.md). It feels more like a true research partner the longer the session goes. The framework is open-source with full documentation) and loading instructions on GitHub. There's also a Medium article covering the methodology and philosophical foundations if you want the deeper background. One honest note: the Ontology Anchor/Ontology%20Anchor%20(OA)) component requires loading your writing exemplars at thread open — about 10 minutes of setup. Read the loading instructions before you start. Skipping that step is the most common mistake. Try it and report what you find. Thanks! submitted by /u/RazzmatazzAccurate82 [link] [comments]

what context do you give Claude so it stops needing the same setup?

i keep repeating the same setup to Claude across workflows. tone, project context, preferred formats, tools i use, what i don’t want, how detailed answers should be. it’s not secret exactly, but it is personal enough that i don’t want it everywhere. i tried project docs. good but narrow. tried giant prompt profiles. noisy. tried summaries, but they get stale. i’m wondering if the cleaner pattern is a small user-owned context file or consented memory layer. what do you give Claude as reusable context without making every prompt huge? submitted by /u/joyal_ken_vor [link] [comments]

LLM delegation - probing task handoff efficiency and economics

So I've been dabbling a bit with multi-LLM orchestration/delegation workflows lately (eg see [Using Claude code to delegate to mistral/deepseek](https://www.reddit.com/r/ClaudeAI/comments/1tjfyh0/i\_used\_claude\_code\_to\_build\_while\_delegating/)). The thread always being how to minimize Claude token usage while still benefiting from Claude's planning and overall code supervision. Offloading context scan and execution is a definite win already (notably against session/weekly quotas for Claude Pro users), so wanted to optimize further the handoff at interface level, beyond standard prompt engineering practice. I'm an electronics engineer by training so I naturally thought of 'black box tests' we run measuring output against different input signals (pulse, step, ramp etc) — this allows us engineers to characterize systemic signal loss (transfer function, impedance mismatch..). I offered the idea to Claude to apply these principles to code, and he came up with a battery of code tests. Setup is Orchestrator (Claude code) delegates tasks to another model (mistral or deepseek) via a cli (vibe or opencode). Orchestrator then receives output and evaluates it against functional tests. *Repo + methodology:* [*https://github.com/pcx-wave/handoff-probe\*\](https://github.com/pcx-wave/handoff-probe) *— if you want to dig in, start with Readme (the 3-layer setup), Methodology (signals), Results (scores), Economics (why delegation saves your session budget).* **Main takeaways :** \- cli/model differences : mainly on tooling and context management. Both CLIs are equally usable (i personally prefer Vibe), but models adapt their output format to task complexity — prose for simple tasks, file writes for complex ones — which creates an inconsistent interface for the orchestrator. Worth enforcing explicitly in the prompt rather than assuming. \- environment definition : critical. A lot of tests failed not because of model incapability, but because the measuring system wasn't reading output in the right way. So setting harness properly (I/O + reading) is critical, and Claude repeatedly failed at self-diagnosing. Almost philosophical : a model will struggle to self-evaluate, it NEEDS external review. Encoding sanity guards (eg 'if you see result score = 0, its likely an error') was one of the more useful things I did. \- don't trust the code looks right, run it. I measured at three levels : format compliance, structural checks, actual execution. Classic prompt engineering stops at the first two. On the hardest tasks, structural checks said 100% success while execution dropped to 58%. The gap between "looks right" and "works right" is where delegation actually fails. Example with async refactor: Structural check: is async def present -yes, 100%. Functional test: does await get\_data() actually run - 58%. Models refactored the signature but left the internals broken. Fix in next point. \- prompt engineering has a measurable impact, although i thought it would be higher. Adding the exact function signature and return type to the delegation prompt recovered about 15% of failures on complex tasks. It costs extra prompt overhead - but you recover costs in the long run by avoiding failures and repeated runs. \- how delegation actually saves your session budget : delegation costs more orchestrator tokens per task than doing it directly, the prompt overhead is real. But when Claude works directly it reads files, and those accumulate in context and get re-read silently on every subsequent turn. With delegation the sub-model handles all of that as none of it enters Claude's context. Savings : \~66% quota reduction on a 10-file codebase, 88% on 30-file one, vs direct. The crossover is simply about 4 source file of reads, below that, direct wins, above it delegation wins by a growing margin. I do not claim this as a benchmark (that would require way higher number of runs, and i'm not specifically trained in the llm field), it's rather a home-made eval tool that can be suited to others running orchestration setups and wanting to probe your delegation setup efficiency at each model interface. submitted by /u/pcx_wave [link] [comments]

Research collection of Arxiv whitepapers [R]

I've launched a hand-curated collection of 1700 Arxiv LLM-focused white paper excerpts knitted together with connecting "inquiring lines" of research - not just topical connections, but shared research angles. For 1700 papers there are 6,000 topic notes that categorize research (alignment, mechinterp, RL, etc). And then 7,000 inquiring lines built from shared research questions (e.g. What explains LLM reasoning?). Because the collection is limited, each inquiring line provides a prompt you can drop into an LLM to find related research that's not in the collection. You can also explore inquiring lines by faceted search (e.g. Reasoning failures & Reasoning traces). I built this in part because papers themselves are so tightly focused on their own research inquiry and related works and methods, it's difficult to find similar projects but in different domains (e.g. personas as alignment solution vs personas used in chatbot conversation vs personas and "emotional" states and reasoning). This project was a rabbit hole that became a full-blown warren demanding everything a Max20 account could bring to bear. I'll be updating it with weekly paper additions going forward. Background I read and collected Arxiv whitepapers starting after the launch of ChatGPT. I copied and pasted excerpts into Word to track them. Then migrated to Obsidian. That vault of some 1700 papers is now online. I figured it was time to see if others would find the collection useful. My whitepapers were organized into some 90 categories, all of which emerged from paper topics. New categories became necessary with the discussion of new methods, techniques, models etc. If I wanted to write about a topic, I'd upload an md file containing research excerpts on that topic to ChatGPT. This worked to a degree but maxxed out context pretty quickly. And I always had related research in multiple categories, according to how the research was framed. (Personas research in Alignment, Psychology, HCI, etc). So I used a plugin to create topic notes that built in and outbound wikilinks across the papers centered on shared concepts. When I ported this all online I added another layer of synthesis: Inquiring Lines as I call them. These cover cross-cutting, tension-surfacing, synthesizing, and frontier-opening research frames. There's 6,000 of them in my collection. Each is a page to itself that's a useful description of a research line of inquiry. These now also have prompts you can run yourself that will find related (and more recent) research - (I can't adequately maintain each topic with new research). It's all at https://inquiringlines.com/inquiring-lines/ if you want to poke around. As is everything in the age of AI, it's a work in progress. But there's a lot of rich material in there. Have a look. https://preview.redd.it/8csrq7533v5h1.png?width=1713&format=png&auto=webp&s=5cc9c453049e6336ac530c6aa88d92a2fd7c8a12 submitted by /u/Barton5877 [link] [comments]

A Colour: a tool that names colours

I have colour-blind people in my whānau and friend group. Colour is slippery: two people look at the same thing and name its shade differently. Both are right. For people with colour vision differences that's not just philosophy, it's daily friction. So I built A Colour. Point your phone, paste an image, or type a word; it gives you the closest colour names. Offline-first, no account, free. Claude helped across the whole build: matching algorithm, TypeScript, copy. But the word mode was the interesting part. Type a noun, get a colour. Four-layer pipeline: a baked distillation lookup (693 hand-curated entries, built with Claude), a TF-IDF + expander layer that handles Te Reo and literal colour names, and finally a fine-tuned sentence transformer running in the browser as the last resort. Two positive prompt templates per entry, MultipleNegativesRankingLoss with in-batch negatives. Fun footnote: Claude got a bit sassy when I asked it to help train a competing model. We got there. Give it a go at colours.preset.nz Source or it didn't happen: https://github.com/rhizomatic-preset/a-colour submitted by /u/countasone [link] [comments]