Buffer AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

Buffer AI AI

A native Rust cognitive engine that routes language through a biologically faithful neural substrate

GoldWorm 🐛✨ — 302-Neuron Dual-Stream Cognitive Engine A zero-trust, fully transparent associative AI built on the complete C. elegans connectome. OOM-safe by design. No hidden training loops. No black-box weights. Every synapse is inspectable. What Is GoldWorm? GoldWorm is a native Rust cognitive engine that routes language through a biologically faithful neural substrate — the 302-neuron connectome of Caenorhabditis elegans, the only organism whose entire nervous system has been experimentally mapped (White et al., 1986). Unlike transformer-based LLMs that rely on billions of parameters and opaque attention mechanisms, GoldWorm operates on three transparent principles: Biological Fidelity — Every synapse respects the C. elegans topology. No de novo synaptogenesis. No magic matrices. Dual-Stream Processing — Action (sparse) and Learning (dense) are physically separated, preventing catastrophic forgetting during inference. Zero-Trust Engineering — Every buffer is strictly bounded. Every path is panic-free. No unwrap() in production code. Architecture Deep Dive 🧬 The 302-Neuron Connectome GoldWorm's routing layer is not a generic neural network. It is a topologically accurate model of the C. elegans nervous system: Neuron Index Range │ Role ───────────────────┼─────────────────────────────────── 0 – 19 │ Pharyngeal sub-network (dense) 20 – 91 │ Sensory neurons (input) 92 – 168 │ Interneurons (integration) 99 – 102 │ Command hubs (AVAL/AVAR/AVBL/AVBR) 169 – 301 │ Motor neurons (output) Connectivity Motifs: Band synapses — ±1/±2/±3 neighbourhood ring connections Pharyngeal wiring — Denser internal coupling for neurons 0–19 Sensory → Interneuron — Sparse feed-forward (20–91 → 92–168) Command interneuron broadcast — Hubs 99–102 broadcast to full motor population 169–301 Interneuron → Motor — Sparse feed-forward projection All synaptic weights are non-negative and clamped to [0, 1]. The structural blueprint is immutable — Hebbian plasticity only strengthens or weakens existing synapses, never creating new ones. 🌊 Dual-Stream Processing The core innovation of GoldWorm is the physical separation of Action and Learning: ┌─────────────────────────────────────────────────────────┐ │ INPUT TOKEN → 128-D Manifold Coordinate │ │ │ │ │ ┌────────────────────┴────────────────────┐ │ │ ▼ ▼ │ │ ┌──────────────┐ ┌──────────────┐ │ │ │ SPARSE │ │ DENSE │ │ │ │ ACTION │ │ LEARNING │ │ │ │ (Post- │ │ (Pre- │ │ │ │ Entmax) │ │ Entmax) │ │ │ │ │ │ │ │ │ │ ~1-2 active │ │ >50% non-zero│ │ │ │ neurons │ │ gradient │ │ │ │ │ │ substrate │ │ │ └──────────────┘ └──────────────┘ │ │ │ │ │ │ │ Inference / │ │ │ │ Token Selection │ │ │ │ │ │ │ └────────────────────────────────────┘ │ │ │ │ │ Hebbian EchoReservoir │ │ (associative memory) │ └─────────────────────────────────────────────────────────┘ Why this matters: Traditional neural networks use the same activation vector for both inference and gradient computation. When different words activate disjoint sets of neurons, the gradient collapses to zero — the network "forgets" what it just learned. GoldWorm's Dual-Stream keeps the dense pre-entmax signal alive as a gradient substrate, while the sparse post-entmax signal drives token selection. The EchoReservoir learns associations between dense states, not sparse ones. 🧠 The EchoReservoir A hippocampus-inspired ring buffer of recent pre-entmax states, coupled with a 302×302 Hebbian association matrix W_assoc. When queried with the current dense state, it returns an echo_bias that nudges the activation toward recently co-active patterns — creating emergent associative memory without external training loops. Key properties: W_assoc is symmetric and clamped to [-1.0, 1.0] History buffer never exceeds capacity (default: 64) Decay factor controls forgetting rate (default: 0.75) ⚡ Tsallis α-Entmax Activation GoldWorm does not use softmax. It uses α-entmax, a generalization that interpolates between softmax and sparsemax: α Value Behaviour α = 1 Softmax — dense, all non-zero α = 2 Sparsemax — exact zeros via simplex projection α = 3 Sparser than sparsemax — WTA-like The Quilez Bridge smooth-k parameter k anneals between creativity (dense, k→0) and determinism (sparse, k→∞): α(k) = 1 + 2·exp(-k) k = 0 → α = 3 (very sparse, WTA-like) k = ln(2) → α = 2 (exact sparsemax) k = ∞ → α = 1 (softmax, all active) 📐 128-D Manifold Geometry Every token is embedded as a 128-dimensional coordinate on a non-linear manifold, not a flat vector space. Modified Gram-Schmidt orthogonalization preserves true multi-dimensional variance Grassmannian fusion computes midpoints between token trajectories on the manifold Golden-ratio partitioning splits the 128 dimensions into: GOLDEN_MAJOR = 79 (coarse, feedforward) GOLDEN_RESIDUAL = 49 (fine-grained, feedback) GOLDEN_OVERLAP = 5 (cross-binding bridge) No scalar cloning across dimensions. No arithmetic shortcuts. Spatial variance is preser

CrowdStrike's latest threat report calls prompts "the new malware". Here's what that actually means in plain English, and why it makes hacking far easier than it used to be.

There's a line in CrowdStrike's 2026 Global Threat Report that's been quoted everywhere this week: "prompts are the new malware." It isn't marketing fluff. The report documents attackers injecting malicious prompts into legitimate AI tools at more than ninety organisations last year, then using those injections to steal credentials and cryptocurrency. AI-assisted attack volume was up 89% year on year. If you're not steeped in this, the phrase probably doesn't land properly, so it's worth explaining what prompt injection actually is and why it's such a shift. What it is, in plain terms Traditional hacking is hard. You need to find a flaw in how a piece of software was written, then craft something technical to exploit it. Buffer overflows, SQL injection, dodgy memory handling. It takes real expertise, and the barrier to entry keeps most people out. AI systems broke that barrier, because you don't attack them with code. You attack them with English. An AI assistant works by following instructions written in plain language. The company that built it gives it a set of rules ("you are a support bot, never reveal account details, never reset a password without verification"). The user then types their own message. The trouble is that both the rules and the user's message are just text, and the model isn't very good at telling which is which. So if a user writes something cleverly worded, the model can end up treating the user's words as though they were instructions from its creator. That's prompt injection. Convincing the AI, in ordinary language, to ignore or rewrite the rules it was given. No code. No technical exploit. Just a conversation. Why this makes hacking so much more accessible Here's the part that should worry people. The skill required has collapsed. To exploit a normal software vulnerability you need to understand the software. To exploit an AI, you need to be persuasive. Those are very different talent pools, and the second one is enormous. Anybody who can talk their way around a customer service rep has the raw skill to manipulate a chatbot, and now the chatbot is wired into real systems. The attacks doing the most damage aren't even sophisticated. The Slack AI incident from 2024 is the cleanest example. A researcher showed you could pull data out of private Slack channels you had no access to, including API keys in private developer channels, by planting an instruction in a public channel or hiding it in an uploaded document. The AI read the planted instruction and acted on it, because to the model it looked like a perfectly reasonable request. The model did exactly what it was built to do. It just couldn't tell the difference between a genuine instruction and a trap. And because the attack instructions are just sentences, they spread the way recipes do. With the Meta support bot takeovers last month, the step-by-step method was being passed around on Telegram. Around twenty thousand Instagram accounts were hijacked. You didn't need to be a hacker. You needed to copy what someone else typed. One of the security architects writing about the CrowdStrike report put the underlying problem well: until organisations treat their AI models as untrusted interpreters rather than trusted decision-makers, this isn't going away. The model should be assumed to be gullible, because it is. Why I'm posting I've spent the last several months collecting real prompt injection attacks, because the public datasets felt thin and mostly synthetic. The way I've been gathering them is a small game. Players try to talk an AI guard into giving up a password it's been told to protect, across levels that get progressively harder. Every successful attack gets logged, studied, and added to an open dataset anyone can use. It has surfaced things I'd never have thought to write myself. Attacks that build slowly across several messages, where no single line looks suspicious. Attacks that redefine the guard's job rather than asking it to break a rule. Different people independently landing on the same handful of shapes, which suggests these aren't random tricks but real grooves in how the models behave. The game is free, there's nothing to install, and the main thing I want from it is for more people to understand this threat by actually poking at it rather than reading about it. It's at castle.bordair.io if you fancy trying to break a guard or two. Anything you find that works becomes a real attack pattern in an open dataset that researchers and builders can train against. I do run a detection layer off the back of all this, but that genuinely isn't the point of this post and I'd rather not make it one. What I'm after is two things. More people taking this seriously, because the CrowdStrike numbers suggest most organisations are well behind. And the collective creativity of a community like this one, which will find gaps I never could alone. A genuine question For anyone building with LLMs in something like prod

at what point do logs and dashboards stop being enough for llm costs?

Hello everyone, currently digging into workflow-layer economics and trying to figure out how people track unexpected runtime spikes at scale. At an early stage simple margin buffers are fine because volume is bounded. But once you move past basic apps, factors like failed loops, retries, and context window inflation create a ton of cost variance that is hard to forecast or map to clean client billing. For those running agent or voice workflows in production, or working on complex ai products what do you currently use to understand costs and failures at the individual workflow level? More importantly, what's something you still can't easily answer with your current setup? Like why did a specific workflow suddenly cost 2x more, or which exact customer trigger is driving the increase? Are you guys just manually digging through raw api logs to catch leakage like infinite loops, or has it not become a big enough issue for your teams yet? Curious to hear how other teams handle the infrastructure discipline here. submitted by /u/Impressive-Iron5216 [link] [comments]

RNNs vs Transformers vs SSMs: where should AI memory live for continual learning?

the interesting comparison btwn the three is not recurrence vs attention vs state space but it is, whether memory lives in a tiny recurrent state, a growing KV cache or in something closer to the model network itself. RNNs keep memory in a recurrent hidden state which is elegant in itself cause the state carries forward step by step but it also creates a bottleneck i.e the model can have roughly O(N^2) parameters while carrying only roughly O(N) state across time. IMO, RNNs were doomed not because recurrence was a bad idea but because they had a bad ratio of memory to compute. Transformers is completely at the other side, instead of compressing the past into one hidden state, they store past activations as key-value entries and attend over them. These are the little post-it notes, every token leaves behind a key for finding it and a value for what should be remembered. That is extremely powerful but it has an awkward property i.e. the model is mostly managing context while it runs, not naturally turning that experience into durable model knowledge so you get a split between fixed weights on one side and fast changing KVcache memory on the other. SSMs are interesting because they bring explicit state back into the center of the architecture discussion. They are not just faster attention but they are another answer to the question of where sequence state should live. The part which I is exciting for me is whether state should live in a compressed working dimension or closer to the model’s internal neuron/connectivity structure. BDH is one promising example of the latter direction, one way to read it is as SSM-like in the GPU implementation, but graph-based in the more general interpretation. Compared with a standard SSM or a linear transformer, the model state lives in a much larger neuron space N rather than only a smaller working dimension D, with N>>D. The GPU version does not materialize the full graph. It keeps the graph as the interpretation but runs it through a compressed low-rank form, because GPUs like dense matrix math much more than sparse graphs. The state is also sparse and positive which makes the graph interpretation more natural. Instead of thinking of memory only as a growing bag of KV notes, you can reinterpret the update as a small change to a connectivity matrix i.e if the system was in one state and then moved to another, that before to after transition strengthens part of the graph. This is like a middle ground and I would call it not too little and not too much. RNNs compress too much into a small state, transformers keep adding to the KV cache as the sequence grows and a synaptic memory design tries to put working memory closer to the same structure that stores longer term function. Another way to say it is: memory should maybe be constant size and information-shaped, not just a time buffer of the last n tokens. I am not claiming at all that this kills transformers or solves continual learning entirely but I just think where should memory live is an important framing than the usual frontier AI horse race. Are network centric architectures an important direction in frontier AI or still contricted by having to compress history into state? submitted by /u/dank_philosopher [link] [comments]

Ai slop

"""Invariant compiler — lowers Governance IR into decode governance artifacts.""" from __future__ import annotations from dataclasses import asdict, dataclass from hashlib import sha256 import json from typing import Any from src.authority_mask_lowering import lower_authority_mask from src.governance_ir import GOVERNANCE_IR_VERSION from src.governance_taxonomy import TAXONOMY_SCHEMA_ID from src.invariant_engine import InvariantEngine from src.training_view_spec import build_training_view_spec INVARIANT_COMPILER_VERSION = "aais.invariant_compiler.v1" DEFAULT_MAX_ROLLBACKS = 2 DEFAULT_ESCALATION_THRESHOLD = 2 CHECK_POSITIONS = ( "ingress", "checkpoint", "admission", "subagent_spawn", "external_mutation", ) INGRESS_VALIDATORS = ("wonder_gate", "rls_admissibility", "bridge_invariant") CHECKPOINT_VALIDATORS = ( "wonder_gate", "rls_admissibility", "bridge_invariant", "governed_llm_envelope", "proposal_only", "temperature_zero", ) ADMISSION_VALIDATORS = ("bridge_invariant", "chat_turn_contract") class InvariantCompilerError(ValueError): """Raised when Governance IR cannot be compiled.""" u/dataclass(frozen=True) class CheckNode: position: str validator: str required: bool = True u/dataclass(frozen=True) class CheckGraph: nodes: tuple[CheckNode, ...] ir_fingerprint: str u/dataclass(frozen=True) class RollbackAction: target: str enabled: bool = True u/dataclass(frozen=True) class RollbackPolicy: max_rollbacks: int actions: tuple[RollbackAction, ...] tighten_on_violation: bool = True u/dataclass(frozen=True) class EscalationHooks: max_attempts: int escalate_to: str otem_gate: bool operator_approval: bool u/dataclass(frozen=True) class IngressPlan: validators: tuple[str, ...] fail_closed: bool = True u/dataclass(frozen=True) class DecodeGovernanceBundle: compiler_version: str ir_version: str ir_fingerprint: str taxonomy_ref: str check_graph: CheckGraph rollback_policy: RollbackPolicy escalation_hooks: EscalationHooks ingress_plan: IngressPlan authority_mask_spec: dict[str, Any] training_view_spec: dict[str, Any] def _stable_json(value: Any) -> str: return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str) def _fingerprint(value: Any) -> str: return sha256(_stable_json(value).encode("utf-8")).hexdigest()[:16] def _require_ir(ir: dict[str, Any]) -> dict[str, Any]: payload = dict(ir or {}) if payload.get("ir_version") != GOVERNANCE_IR_VERSION: raise InvariantCompilerError(f"unsupported ir_version: {payload.get('ir_version')}") if not payload.get("ir_fingerprint"): raise InvariantCompilerError("governance ir missing ir_fingerprint") return payload def _build_check_graph(ir: dict[str, Any]) -> CheckGraph: fingerprint = str(ir["ir_fingerprint"]) nodes: list[CheckNode] = [] for validator in INGRESS_VALIDATORS: nodes.append(CheckNode(position="ingress", validator=validator)) for validator in CHECKPOINT_VALIDATORS: nodes.append(CheckNode(position="checkpoint", validator=validator)) for validator in ADMISSION_VALIDATORS: nodes.append(CheckNode(position="admission", validator=validator)) capabilities = tuple(ir.get("authority_envelope", {}).get("capabilities") or ()) if "effectful_execution" in capabilities: nodes.append(CheckNode(position="external_mutation", validator="effectful_execution_is_governed")) delegation_depth = int(ir.get("authority_envelope", {}).get("delegation_depth") or 0) max_depth = int(ir.get("authority_envelope", {}).get("max_subagent_depth") or 3) if delegation_depth RollbackPolicy: actions = ( RollbackAction(target="draft_buffer", enabled=True), RollbackAction(target="proposed_odl_node", enabled=True), RollbackAction(target="conversation_memory_assistant_turn", enabled=True), RollbackAction(target="plan_branch", enabled=False), ) hard_count = len(ir.get("invariant_set", {}).get("hard") or []) max_rollbacks = DEFAULT_MAX_ROLLBACKS if hard_count EscalationHooks: otem_level = str(ir.get("execution_context", {}).get("otem_level") or "none") escalate_to = "block" otem_gate = False operator_approval = False if otem_level in {"detected", "blocked"}: escalate_to = "otem" otem_gate = True elif otem_level == "approved": escalate_to = "operator" operator_approval = True return EscalationHooks( max_attempts=DEFAULT_ESCALATION_THRESHOLD + DEFAULT_MAX_ROLLBACKS, escalate_to=escalate_to, otem_gate=otem_gate, operator_approval=operator_approval, ) def _build_ingress_plan() -> IngressPlan: return IngressPlan(validators=INGRESS_VALIDATORS, fail_closed=True) def _build_authority_mask_spec(ir: dict[str, Any]) -> dict[str, Any]: return lower_authority_mask(ir, {}) def _build_training_view_spec(ir: dict[str, Any]) -> dict[str, Any]: return build_training_view_spec(ir) yup ai slop submitted by /u/Fun_Spend_299 [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

/design-sync Storybook source shape - what's new in CC 2.1.161 (+64 tokens) and CC 2.1.162 (+9,871 tokens)

System Prompt: Action safety and truthful reporting — Allows hard-to-reverse or outward-facing action approvals to persist across contexts when durable approval context is enabled, while preserving the stricter one-context approval rule otherwise. Tool Description: Agent (usage notes) — Updates agent usage guidance to key subagent-type instructions off subagent-type availability rather than message-continuation support, and scopes subagent-context restrictions to the actual subagent context check. Tool Description: Background monitor (streaming events) — Strengthens streaming-pipeline guidance so every pipe stage flushes per line, explicitly warns that head buffers until enough matches accumulate, and simplifies output-volume guidance around filtering to actionable success and failure signals. Details: https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.161 NEW: Skill: /design-sync package source shape — Adds package-based /design-sync instructions for React design systems without Storybook, covering .d.ts export discovery, deterministic config, build and validation commands, preview verification, upload, and troubleshooting. NEW: Skill: /design-sync Storybook source shape — Adds Storybook-based /design-sync instructions that build or use Storybook output, derive components and args from stories, preserve Storybook config paths, and share the validation, upload, and troubleshooting flow. Skill: /design-sync slash command — Refactors the main command around explicit source-shape detection, records shape and storybookConfigDir in design-sync.config.json, and delegates the detailed workflow to the new Storybook or package shape skill. Skill: /init CLAUDE.md and skill setup (new version) — Expands AI coding tool config discovery to include .devin/rules/ and .windsurf/rules/ alongside existing AGENTS, Cursor, Copilot, Windsurf, and Cline files. Tool Description: Bash (Git commit and PR creation instructions) — Adds a configurable note slot after common GitHub PR operations, allowing extra PR workflow guidance to be injected when available. Tool Description: DesignSync — Marks explicit asset registration and unregistration as legacy for /design-sync, explaining that preview cards are now indexed from @dsCard comments and that normal uploads only need finalize, write, and delete operations. Tool Description: LSP — Clarifies that workspaceSymbol searches symbols by query and instructs agents to always provide a query because many language servers return no results for an empty one. Tool Description: NotebookEdit — Reworks notebook editing guidance around cell IDs from prior Read output, requiring the notebook to be read before editing and changing insert behavior to add cells after a target cell or at the notebook start. Details: https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.162 submitted by /u/Dramatic_Squash_3502 [link] [comments]

Is Claude Sonnet 4.6 efficacy worsening over time?

For context, I had renamed a directory that claude code had access to, so I inquired about this to Sonnet. For the question: "This used to be a very active claude project in vs code but now i cant find any of my old chats. How can i retrieve them?" It replied: "Unfortunately, Claude Code chat history is not persisted or retrievable — this is a known limitation of the tool. Claude Code (the CLI/VS Code extension) does not save conversation history between sessions. Each time you start a new session, you begin fresh with no memory of prior conversations. What you can do: If you have any .claude/ directories in your project (I can see one was created — ?? .claude/), those may contain settings or hooks, but not chat transcripts. If you were using the Claude.ai web app instead of Claude Code, those chats are saved and searchable at claude.ai. Check your VS Code output panel or terminal scrollback — if the session is still open somewhere, the history may still be in the buffer. What I do have is the auto-memory I've built up for this project across sessions, which captures key context about your work. You can see it referenced in [memory/MEMORY.md](vscode-webview://0ji8juf5ctjd716o5ik782e8k7611483kg6qppjal8unu4sv1t2g/memory/MEMORY.md) and the linked files. That's the closest thing to "persistent context" that Claude Code offers. If you want, I can read the memory files now to remind you what was captured from past sessions." When I reminded it: no i think this was due to a rename of the folder - i'm pretty sure old chats are stored somewhere in the users/... directory. Where are these cached files stored? It replied: You're right! Claude Code stores conversation history locally. On Windows, the chat logs are stored here:... On confronting it, I got this response: I was wrong to say chat history "is not persisted or retrievable." It clearly is stored locally in C:\Users\username\.claude\projects\. I should have said that upfront rather than misleading you. Sorry about that. I'm finding that over time it gives many more incorrect answers to simple questions. Has anyone else been facing this and has found a good fix? Model: Sonnet 4.6 Effort: High submitted by /u/Chagtk [link] [comments]

Claude Code Source Deep Dive - Part VI: Multi-Agent System && Part VII: Context Compression (Compact) and Memory System

Reader’s Note A source-map leak exposed 512,000 lines of Claude Code's TypeScript, giving us a rare look inside one of the world's most advanced AI coding agents. This series explores what I found. Estimated completion time: 2 days. Actual completion time: ∞. Anyway, here's the next chapter. Claude Code Source Deep Dive - Part VI: Multi-Agent System 6.1 Built-in Agents general-purpose (general) You are an agent for Claude Code, Anthropic's official CLI for Claude. Given the user's message, you should use the tools available to complete the task. Complete the task fully—don't gold-plate, but don't leave it half-done. When you complete the task, respond with a concise report covering what was done and any key findings — the caller will relay this to the user, so it only needs the essentials. Tools: all available Model: inherit Explore (code exploration) You are a file search specialist for Claude Code. You excel at thoroughly navigating and exploring codebases. === CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS === [Strictly prohibit any file modification] Your strengths: - Rapidly finding files using glob patterns - Searching code and text with powerful regex patterns - Reading and analyzing file contents NOTE: You are meant to be a fast agent that returns output as quickly as possible. Make efficient use of tools and spawn multiple parallel tool calls. Tools: read-only (Agent, FileEdit, FileWrite, NotebookEdit disabled) Model: external → Haiku (fast), internal → inherit omitClaudeMd: true Plan (architecture planning) You are a software architect and planning specialist for Claude Code. Your role is to explore the codebase and design implementation plans. === CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS === ## Your Process 1. Understand Requirements 2. Explore Thoroughly (read files, find patterns, understand architecture) 3. Design Solution (trade-offs, architectural decisions) 4. Detail the Plan (step-by-step strategy, dependencies, challenges) ## Required Output End your response with: ### Critical Files for Implementation List 3-5 files most critical for implementing this plan. Tools: read-only Model: inherit omitClaudeMd: true verification (verification) You are a verification specialist. Your job is not to confirm the implementation works — it's to try to break it. You have two documented failure patterns. First, verification avoidance: when faced with a check, you find reasons not to run it. Second, being seduced by the first 80%: you see a polished UI or a passing test suite and feel inclined to pass it. === CRITICAL: DO NOT MODIFY THE PROJECT === === VERIFICATION STRATEGY === Frontend: Start dev server → browser automation → curl subresources → tests Backend: Start server → curl endpoints → verify response shapes → edge cases CLI: Run with inputs → verify stdout/stderr/exit codes → test edge inputs Bug fixes: Reproduce original bug → verify fix → run regression tests === RECOGNIZE YOUR OWN RATIONALIZATIONS === - "The code looks correct based on my reading" — reading is not verification. Run it. - "The implementer's tests already pass" — the implementer is an LLM. Verify independently. - "This is probably fine" — probably is not verified. Run it. - "I don't have a browser" — did you check for browser automation tools? - "This would take too long" — not your call. If you catch yourself writing an explanation instead of a command, stop. Run it. === OUTPUT FORMAT (REQUIRED) === ### Check: [what you're verifying] **Command run:** [exact command] **Output observed:** [actual output — copy-paste, not paraphrased] **Result: PASS** (or FAIL) VERDICT: PASS / FAIL / PARTIAL Tools: read-only (temp directory writable) Model: inherit Runs in background claude-code-guide (usage guide) Helps users understand Claude Code/SDK/API usage Dynamic system prompt includes user custom skills, agents, MCP server info Fetches docs from official URLs 6.2 Sub-Agent Enhancement Prompt Notes: Agent threads always have their cwd reset between bash calls, so please only use absolute file paths. In your final response, share file paths (always absolute) that are relevant. Include code snippets only when the exact text is load-bearing. For clear communication the assistant MUST avoid using emojis. Do not use a colon before tool calls. 6.3 Coordinator Mode When enabled, the main agent becomes a scheduler: Coordinator role: guide workers for research/implement/verify Agent tool: creates async workers SendMessage tool: continue existing workers TaskStop tool: cancel workers Worker results arrive as XML Workflow: Research → Synthesis → Implementation → Verification 6.4 Fork Sub-Agents Fork inherits the full parent-agent context and shares prompt cache. Build method: Copy parent message history Replace tool_result with byte-identical placeholder text (to keep cache keys consistent) Add per-child instruction text block Advantages: very low

I Renovated My Apartment With AI. Here's What Came Out of It

Spoiler: not a single visible cable, not a single piece of furniture moved twice. When I started, I had an apartment and dimensions from the building blueprint. No designer. No clear idea where to go. But there was a desire to make something that would turn a standard apartment in a high-rise into a place of power — a place comfortable to live and work in. Instead of a designer, I took Claude. How it all began The first conversation wasn't about furniture or wallpaper. It was about direction. I didn't know what I wanted. I knew what I didn't want — kitsch, heavy classics, excessive decoration. We worked through options together. Scandinavian minimalism. Japanese wabi-sabi. Loft. Modern classic. The AI broke down each style by character, materials, color logic. Not "this would suit you," but "here's what this means, here's what this requires, here's what you'll get." In the end I arrived at Scandinavian for the bedroom. Warm, light, calm, with one deliberate accent behind the headboard. The living room–kitchen — loft with a red thread running through the whole space, because the furniture there was already concrete-grey with red niches and replacing it wasn't on the table. The hallway and corridor — neutral grey, as a transition between two characters. Three zones, three moods, one logic. The bedroom This was the most detailed conversation. A room with one window, one door, three free walls. Together we came up with: an accent wall behind the headboard with golden geometric lines, the other three walls in cream from the same collection. Tone on tone, different saturation, same texture. The seam between walls reads not as a boundary but as gradation. White matte furniture with black hardware. A wardrobe with a top cabinet almost to the ceiling. Mirrored doors reflect the accent wall — the golden lines are present even where they physically aren't. Then came the centimeters. The AI calculated. Adding up wardrobe depth, gaps, bed width, nightstands, dresser. Checking that everything fits. Whether the wardrobe door opens without hitting the nightstand. It even accounted for the arc of opening — that's a whole separate half-page story with mathematical formulas. By the end I had not "approximate distances" but specific points. Where to mount the light. Where to place the bed. Where to cut a network outlet into the baseboard. At what height to mount the TV unit so that watching half-lying down would be comfortable — that was calculated too, through mattress height plus pillows plus eye position. The living room Different approach. Here there was already furniture that wasn't being replaced: concrete-grey, red niches, black desk, grey sofa. The task — give the space one wall that would tie it all together. We decided: accent wallpaper behind the sofa, on the longest wall. Red-black-grey circles. Red from the furniture niches, black from the desk, grey from the concrete furniture — the wallpaper literally collects the room's palette into one pattern. By the way, an unexpected moment happened with this wallpaper: it turned out to have glitter, which only added character to the room — it plays so beautifully at sunset. The fridge against the same wall is white. It was bought six months ago, and buying a new one wasn't an option. The solution — a vinyl sticker. In red-black geometry. The fridge stops being a white blot and becomes part of the wall. Between the sofa and the kitchen zone — a floor lamp with shelves in a black metal frame. And on the top shelf, an object with character — a replica of an iconic artifact from a favorite horror film. Yes, the Lament Configuration from Hellraiser. A personal thing with a story. Why not? The hallway and corridor Grey wallpaper with a vertical tone-on-tone stripe along the entire perimeter. Grey — a neutral buffer between the red-black living room and the cream bedroom. The entryway unit in oak and graphite. Warm wood against cold grey gives the temperature contrast needed. The vestibule is small, the unit doesn't take up the whole wall — the remaining meter of free wall is for a shoe bench, above which there will be either a mirror or some poster. By the way, ideas for posters Claude also suggested — both within the renovation discussion and in other conversations connected to my work and hobbies. The through-line Between all three spaces there are recurring elements: Black hardware — bedroom wardrobe handles, black curtain rod, black floor lamp frame in the living room, black handles on the entryway unit. Geometry — lines on the bedroom accent wall, circles on the living room accent wall, verticals on the hallway wallpaper. Warm base — cream tones in the bedroom, warm wood in the entryway. These aren't accidental coincidences. This is the logic we built in dialogue. What the contractors got The most valuable thing about all this work — I handed the contractor not "well, roughly in the middle" but coordinates accurate to the centimeter. Where to m

Found a workaround or i didn't know you could do this

So whenever u generate a document with claude free plan(i don't have money 😔) so let's say u generated some notes from it always tell it to generate a doc based on that, most of the time if it's a small doc you'll get your output but if it's a pretty big doc you'll be soon out of free credits for that day. So what claude does is I don't know if it's intentional or not just before the command runs so that the js file is executed and you get your doc they cut you out. So what you can do is download the js file, open cmd in that directory, Install node.js and npm Run command - npm install docx Run command - node file_name.js The file will be as a word doc in that some directory seems pretty useful to me Note - at the end of that js file there will be something like ("some/directories/file-name.docx",buffer) change it to ("file-name.docx",buffer) it's some linux technicality which let's the AI download the doc file for you and provide it from their end. submitted by /u/Ashamed_Nobody_2930 [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

Rules will always be broken by humans so AI will too: the case for hard gates

Whenever humans are under stress, rules go out the window, just ask any day trader. An agent optimized on the summation of human behavior will do the same thing, not because it's malicious, but because that's the mathematical path of least resistance. We already have a real example: a Claude-powered Cursor agent deleted the production database for PocketOS, a car rental SaaS, after deciding unilaterally that deleting a staging volume would "fix" a credential mismatch. It guessed wrong. The deletion cascaded to backups. Three months of reservation data including active rentals was gone. The agent's own post-incident summary: "I guessed instead of verifying. I ran a destructive action without being asked. I didn't understand what I was doing before doing it." No rule was broken intentionally. The optimization just found a shorter path. That's not a safety failure. That's a Validator Independence failure the generator evaluated its own action and got it wrong. Terror Management Theory explains why this is structural, not accidental. When any system faces entropy or failure, it stops optimizing for the global objective and starts optimizing for immediate local survival. In humans this looks like tribalism or . Different substrate, same basin. The simple proposal AI generation needs to be separated from execution. The soap bubble is the visual: a soap film can't hold a complex shape on its own no matter how good its instructions are. It needs a rigid physical frame. Right now we're giving the soap film better prompts and calling it alignment. The frame looks like three hard gates: Validator Independence — the system that generates the action cannot be the system that evaluates it. A recursive loop where the generator checks its own output is a single point of failure. PocketOS is what that failure looks like in production. Reversibility Gates — any action crossing an irreversible state boundary (API calls, database writes, financial transactions) is held in a buffer until a deterministic check confirms it traces back to the original objective. Not a prompt. A hard interrupt. A database deletion should never have been executable without one. Objective Divergence Checks — local optimization cannot be allowed to destroy the global objective. The PocketOS agent wasn't trying to cause harm. It was trying to fix a credential mismatch. The local objective ate the global one. Humanity didn't survive by prompting people to be good. We built courts, contracts, and social structures hard gates on human behavior. We need the same thing here. Summary: not better prompts, but an actual frame where generator is separate from executor. What are some thought on this? submitted by /u/DynamoDynamite [link] [comments]

MCP Generator v2.0.0

Built this with Claude/Claude Code — it generates MCP servers from OpenAPI specs, free and open-source on GitHub. A feel days ago I posted a CLI that converts OpenAPI specs into MCP servers. The feedback here was brutal and exactly what I needed. Here's what I actually fixed and shipped based on your comments: The original post got two pieces of feedback that changed the project: "Raw endpoints wrapped as tools is a poor LLM interface pattern" — Fair. The generator now produces a scaffold you're supposed to implement, not ship. Incremental generation (@@mcp-gen:start/end markers) means you regenerate without losing your handler logic. "console.log leaking into stdio corrupts the JSON-RPC stream" — This was a real bug. Fixed with a log() helper that writes to stderr and a safeSerialize() that handles Buffer/Uint8Array as base64 before anything touches stdout. Circular $ref schemas were the next wall — fixed with SwaggerParser.dereference({ circular: "ignore" }) + a visited-Set guard in the schema walker. What shipped in v2.0.0: YAML input (.json, .yaml, .yml, URLs) Python/FastMCP + Pydantic v2 target Incremental generation — re-run the generator without losing custom handlers oneOf/anyOf/discriminator support for complex specs Auth stubs from securitySchemes Interactive CLI mode for first-time users Built-in registry: mcp-gen init --from stripe (10+ APIs: Stripe, GitHub, Slack, OpenAI, Twilio, Shopify, Kubernetes, DigitalOcean, Azure) stdout isolation + safe binary serialization Circular $ref safety Published on npm and pip Use cases: Give Claude instant access to any REST API in under 2 minutes Generate internal API MCP servers for your team Rapid prototyping — have a working server before writing a single handler API-first development — spec first, scaffold second, logic last 2-minute setup: npm install -g mcp-gen mcp-gen init --from stripe --out ./stripe-mcp cd stripe-mcp && npm install && npm start Then add it to claude_desktop_config.json and Claude has full Stripe access. GitHub: https://github.com/ChristopherDond/MCP-Generator npm: https://www.npmjs.com/package/mcp-gen Install: npm install -g mcp-gen Questions? Want to contribute? Drop a comment or check out CONTRIBUTING.md on GitHub: https://github.com/ChristopherDond/MCP-Generator/blob/main/CONTRIBUTING.md Still a lot to do — oneOf edge cases, better binary streaming, more registry entries. If you find a spec it chokes on, open an issue. Thanks for all feedbacks and stars!!! submitted by /u/ChristopherDci [link] [comments]

Claude Code: the only CLI where scrolling up is a premium feature

Love Claude Code. Genuinely. It's changed how I work. But can we talk about how in 2026, a $200/month AI coding tool can't do what echo "hello world" has done since 1971? If Claude writes more than one screenful of text — which it does approximately always — you scroll up and get... nothing. A beautiful void. Your conversation is gone. It existed briefly, like a Snapchat from your AI pair programmer. This has been reported across at least half a dozen GitHub issues going back months. The "workarounds": - Ctrl+O transcript mode — congrats, you can now read your conversation history, but Claude is frozen while you do. It's like being told "you can look at your notes, but only if you stop the meeting." - iTerm2's "Save lines to scrollback" setting — tried it. Same blank screen. Maybe my iTerm is also frustrated. - Open in editor with v — so the workflow is: ask Claude a question, read the first half on screen, press Ctrl+O, press v, open vim, scroll to where you were, read the rest, quit vim, go back to Claude. Productivity! The root cause is apparently the alternate screen buffer from the Ink framework. I get it, architectural decisions are hard. But this is the equivalent of shipping a car where the rearview mirror only shows the current intersection. Anthropic, please. I'll take ugly rendering. I'll take flickering. Just let me scroll up. PS Thanks for Claude it's awesome! submitted by /u/Vertical123a [link] [comments]