Sweep

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

Sweep AI

How competitive are PhD admissions currently [D]

Hi, how hard is it currently to get a PhD position in machine Learning? Like what are the requirements to get to a decent mid tier program (= they publish regularly at respected journals and their work gets read my some people)? How is it in different regions e.g US, Europe, etc.. I am about to finish my masters and am wondering if I need to sweep in an unpaid guided research project to extend my network. submitted by /u/strammerrammer [link] [comments]

Could AI be indirectly addressing the imbalance in equality of opportunity due to our differences in IQ?

I had been thinking about how schools work when I realised it seems as though you're first taught how to work then why to do the work. I think that was a perfectly reasonable mode of operation at the time formal education was being introduced because it wasn't at a time when we were exactly as skeptical as we are now about the corrupt foundations of our systems of authority. This is to say that, back then, because of how high stakes survival was, people weren't so comfortable existing without order. This also isn't to say that established order is perfect, and nothing of value can be found through exploration, but in fact to say that this is how innovations come to be, and that there was a lot more respect for keeping things in order because the other option was effectively desperation. Nowadays, with the justification upon which western and westernised civilisations developed being shaken, as in the belief in Judeo-Christian values, the established order seems archaic, which is usually the first step towards a sweeping change, which could be revolutionary improvement or a flood. Why does that matter? While I believe getting entirely rid of the influence that our foundational belief has on our culture would be catastrophic, i don't think there are no improvements to be made and in fact can't conceptualise the point where there exists no improvement). Think of the foundational belief/philosophy of 'Loving the Lord your God (which I understand as having the utmost respect for pure truth which leads to true love) and then loving your neighbour as you love yourself' as a current that carries us through time. Some currents are full of rocks while some provide safe passage. This current has led to the greatest civilisation man has recorded thus far. So to get rid of surfaces you can do without to further avoid collisions is what we're supposed to do. We're now at a point where 'switching streams' seems to be a central focal point of cultural, political and philosophical conversations, meaning the respect for the old mode is quickly disappearing and so, for example, few really think about the reasoning behind being educated in the first place. We effectively now aim for careers with shining titles rather than those whose effect we first identified as positively impacting a community, or end up aiming in other directions which is more often than not a very good idea. The reasoning behind the greatness of a doctor is now reflected by their paycheck, when in fact the paycheck is actually effectively determined by the value the community sees in their effort, or at least that comes as an afterthought. If schools increase focus on expressing why and what effect the subject is important they can peak the interest of students in their subjects. The fundamental things we seek as humans are quite constant, they're just 'flavoured' by the culture you're in. From this perspective, a teacher can understand how to frame lessons to specific students. Of course, even in the things we want fundamentally there exist those we ought not to give into, as in, exactly what would constitute falsehood and not loving your neighbour as you do yourself. This is the true basis of what we have now thats any good, that is, look into yourself to find out what people appreciate, look for the resource to build it and bring it to the community in hopes that they appreciate it, then the community reciprocates through a token of appreciation, which they themselves think is a 'fair compensation for your troubles in bringing them the convenience'. What we have a lot of nowadays are people selling the illusion of convenience, and people convinced that this is the method. We actively look inside ourselves for ways to successfully deceive, and use this to guide other into their own loss at our profit, which is practically flipping our foundational belief on its head. I think a lot of this is caused by the hopelessness some may feel struggling to understand something they can't and are constantly berated without even knowing what they're working for, or others simply driven by a spotlight. With AI which can understood to be a heightened IQ for all, ignoring all the controversy that can't be concluded on, with such an approach we can have a lot more people working toward identifying problems and easily finding technical solutions to them, which would definitely create more job opportunities even temporarily, as AI develops to complete even more complicated tasks, with the ease with which these conveniences are produced increasing, lowering costs and therefore prices. We may end up with a culture more focused on understanding oneself in order to benefit others and thrive yourself. Ai will know how to do complex tasks, but expecting it to understand what people will appreciate to the point of being profitable requires us to make it perfectly in tune with the nature of human experience, which we ourselves aren't, but are definitely closer to, and ap

ai slop? who knows~

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

CFS-R: Conditional Field Reconstruction

I evaluated CFS-R on LoCoMo (1,982 questions, same setup as the CFS evaluation), holding cosine and BM25 fixed and varying only the third leg. baseline cosine top-10: NDCG@10 0.5123, Recall@10 0.6924 rrf(cos, BM25): NDCG@10 0.5196, Recall@10 0.6989 rrf(cos, BM25, MMR tuned): NDCG@10 0.5330, Recall@10 0.7228 rrf(cos, BM25, CFS-long): NDCG@10 0.5362, Recall@10 0.7295 rrf(cos, BM25, CFS-R top50 w3): NDCG@10 0.5447, Recall@10 0.7303 Against tuned MMR: +1.17 pp NDCG@10 (95% CI [+0.66, +1.69], p < 0.001). Against CFS-long: +0.85 pp NDCG@10 (95% CI [+0.33, +1.35], p = 0.0006). Against baseline cosine: +3.24 pp NDCG@10, +3.79 pp Recall@10. The sweep wasn’t fragile.. the top configurations clustered tightly between 0.5441 and 0.5447 NDCG@10, which means the operator is on a stable plateau rather than a single magic hyperparameter. The category breakdown is where the conceptual difference shows up: single-hop multi-hop temporal open-dom adversarial tuned MMR 0.3479 0.6377 0.2938 0.6144 0.4705 CFS-long 0.3615 0.6376 0.2959 0.6157 0.4734 CFS-R top50 w3 0.3646 0.6344 0.2948 0.6209 0.5018 The adversarial line is the result that matters: +3.13 pp over tuned MMR, +2.84 pp over CFS-long. If the adversarial problem were only pairwise diversity, MMR should be very hard to beat but it isn’t. That supports the main claim: long-memory retrieval is not just about avoiding similar chunks. It is about reconstructing the evidence behind the query. Temporal is no longer a glaring weakness either, CFS-long still slightly leads, but CFS-R has closed the gap while keeping the adversarial gains. https://gist.github.com/M-Garcia22/542a9a38d93aae1b5cf21fc604253718 submitted by /u/mauro8342 [link] [comments]

Wait I thought I was the human here

Opus 4.7 is impersonating me. Maybe this is next level automation from Anthropic submitted by /u/OddOriginal6017 [link] [comments]

V-JEPA 2.1's dense features are partitioned: a robustness study across all four model sizes [R]

I ran a pre-registered robustness study on Meta's V-JEPA 2.1 across all four released model sizes (80M → 2B). 322-cell sweep Three findings worth flagging: 1. Dense features are partitioned. M2 (representational drift between clean and perturbed clips, measured as cosine distance on temporal-gradient vectors) predicts downstream task failure on DAVIS for temporal corruption (frame drops r=0.37 [0.30, 0.44], occlusion r=0.35 [0.28, 0.42]). For image-noise corruption, the correlation is statistically indistinguishable from zero (Gaussian r=−0.06, motion blur r=+0.09, low-light r=+0.05; all CIs cross zero). The two perturbation families are statistically separable at 95% confidence (closest CI gap +0.106). Aggregate r=0.16 [0.13, 0.20] is below both the pre-registered ambiguous threshold (0.30) and confirmation threshold (0.50). 2. Bigger is not reliably better. Every Tier 1 perturbation showed non-monotonic robustness. The 2B "gigantic" model is less robust than the 1B "giant" variant on three of the five perturbations. All jumps >5× their pooled CI half-width. 3. V-JEPA 2.1 is meaningfully orientation-sensitive. Horizontal flip preserves all temporal structure but disrupts representations comparably to playing the video backwards (M2 = 0.91 across all models vs. predicted upper bound of 0.30). Not orientation-equivariant out of the box. Six hypotheses pre-registered with explicit numerical decision rules. Two confirmed, three refuted, one partially withdrawn during analysis - the M1 component of H2 turned out to be ill-defined under reverse playback (M1 assumes preserved frame ordering, which time-axis perturbations break). Documented and not buried. Proposed mechanism for the non-monotonic scaling result: hub marginalization in deep ViTs (arXiv:2511.21635). Deeper models can over-shoot from "single hub aggregator" to a regime where extra layers scramble information rather than refine it. V-JEPA's dense predictive loss explicitly pushes against single-hub aggregation; if the 2B variant has crossed into the over-communication regime while the distilled 300M retains controlled mixing, the pattern is what hub marginalization predicts. Code, reproducibility manifest, raw shards: https://github.com/poisson-labs/vjepa-stress Full writeup: https://poissonlabs.ai/research/vjepa-2-1-robustness Happy to discuss methodology, the partitioning interpretation, or the hub-marginalization argument. The image-noise side of partitioning (gaussian/motion blur/low-light CIs all crossing zero) is the part I'd most like skeptical eyes on. submitted by /u/poisson_labs [link] [comments]

I built a “Living Docs” system for long-term AI coding workflows

English is not my first language. AI actually told me to post this here, and also helped write this post 😅 After months of AI-assisted coding, I kept running into the same problems: - repeating architecture context every session - stale docs - conflicting rules - context drift - AI modifying wrong parts of the project - knowledge disappearing between sessions So I started building a documentation system specifically for AI workflows. The idea became something I now call “Living Docs”. Core idea: The same agent that changes the code is also responsible for maintaining the documentation and operational memory. But there is one important constraint: Documentation is NOT updated automatically after every task. The human confirms the code is correct first. Then the agent performs a deliberate “doc sweep” to sync the docs. Otherwise wrong code can mutate the docs, and then future sessions start treating incorrect behavior as truth. Some core rules from the system: One file owns each rule. No duplication. If a rule exists in two places, you now have two sources of truth, which means you have none. Code is primary truth for behavior. Docs are primary truth for intent. The docs are not static reference material. They act as institutional memory shared between humans and AI across sessions. The architecture has 3 layers: - codebase - LLM-maintained docs - governance/schema layer The governance layer tells the agent: - which docs to load - which file owns what - when documentation updates are allowed - how to prevent duplication and context drift Still experimental, but it already improved long-session stability a lot for me on larger projects. Repo: https://github.com/Diew/living-docs Would genuinely love feedback from people working with Cursor, Claude Code, Aider, Roo, OpenHands, etc. submitted by /u/RenAzure [link] [comments]

Four free Claude Code skills from building an iOS/macOS app with Claude

These skills came out of building Stuffolio, a Universal iOS / iPadOS / macOS app, and they're skills I use often. All four are free, Apache 2.0, no paid tier. Each link below has a sample of the actual output if you want to see what comes back before you install. prompter rewrites your Claude Code prompt for clarity before it runs. It resolves "that file" to a path, sharpens vague verbs, and restructures stacked questions. Importantly, it skips rewriting when the prompt is already clear, so it doesn't add friction to the easy ones. Worked examples across 8 categories. tutorial-creator turns a file from your own project into an annotated reading tutorial with vocabulary tracking, pre and post tests, and prerequisite gap analysis. Language-agnostic. Sample outputs: a starter walkthrough and a more advanced one. bug-echo is the after-fix sweep. Once you fix a bug, It reads your fix, confirms the anti-pattern, then scans the codebase for other instances of the error. Each match is read in context and classified BUG / OK / REVIEW. It honors #if os(...) blocks, so Universal codebases don't surface false positives across platforms. Sample report from a real run. bug-prospector is the forward-looking audit. It runs 7 lenses (assumptions, state machines, boundaries, data lifecycle, error paths, time-dependent bugs, platform divergence) to find code that compiles fine and passes tests but breaks under conditions you haven't exercised yet. It asks up front whether the project is iOS, macOS, or Universal so findings respect your platform set. Works well with bug-echo. Run prospector before releases, echo after prospector fixes. Sample report. Happy to answer questions, and I appreciate any feedback. (Disclosure: Stuffolio is my app; the skills are independent of it and free to use anywhere.) submitted by /u/BullfrogRoyal7422 [link] [comments]

Keeping a Claude Code session running 24/7 (and accessible from my phone) without leaving the terminal

Disclaimer: While I did use Claude Code to help build this, all code has been reviewed by a human, and I've been using this for weeks without any issues. I do most of my Claude Code work in the terminal. The web/desktop apps are fine, but claude in tmux is where I actually want to live. It's always the same shell, same dotfiles, same MCP servers, same skills, no context-switching to a different surface just because I'm replying from my couch. Problem: a terminal session dies when the terminal dies. And there are real things I want a long-running agent to do, like answer me on Telegram while I'm out, run a daily brief at 7am, sweep my inbox at lunch, spawn a fresh coding agent on a worktree when I want to work on something. So I built Leo: a process supervisor and scheduler for the claude CLI. What it does Supervises long-running claude processes. Each runs in its own tmux session with auto-restart. I run one as my personal assistant, wired to Telegram via the --channels flag. Personality and operating rules can live in a custom subagent file or CLAUDE.md, which means the same identity travels with me into terminal sessions too — no syncing memories/MCPs/skills between two systems. Cron-driven tasks. Standard cron syntax, prompt-from-file, optional channel notify on failure. Mine fires daily briefings and inbox sweeps. Ephemeral coding agents from templates. leo agent spawn coding blackpaw-studio/leo gives me a fresh tmux session with a claude REPL pre-cloned into that repo. With remote-control on, the same agent shows up in the Claude app too. The leo CLI doubles as a thin SSH client, so I can manage agents on my Mac Mini server from my laptop without leaving the terminal. One daemon, web dashboard, token-authed HTTP API, MCP server. Every channel gets /clear, /compact, /agent spawning, /tasks management for free. Channel-agnostic on purpose. Leo doesn't ship messaging. You install any Claude Code channel plugin (Telegram, iMessage, Discord…) and reference its ID in channels:. The plugin owns its own auth; Leo just passes the resolved list to the spawned process. Install brew install blackpaw-studio/tap/leo # or curl leo.blackpaw.studio/install | sh # or go install github.com/blackpaw-studio/leo/cmd/leo@latest Prereqs: authenticated claude CLI, tmux. macOS and Linux. Website: https://leo.blackpaw.studio Repo: https://github.com/blackpaw-studio/leo Docs: https://docs.leo.blackpaw.studio submitted by /u/edc1591 [link] [comments]

Building a 9-ball AI player: Candidate generation for direct cut shots [P]

I'm building a 9-ball-player to help with pattern play. There are many ways to make the next ball, and sometimes in more than one obvious pocket. Which should should you choose depends on probability of making that shot AND ending up in a favorable spot for the next shot, that is also amenable to getting good position for the shot after. To that end, I have built the following components: A transformer based model that learns p(win) given a table layout. Candidate shot generator that includes cut shots, bank shots, kick shots, caroms and combination shots as well as safeties. An evaluator that will pick the best shots based on the p(win) model on the resulting state of each candidate shot. The ground truth: pooltool Pool physics is well-modeled but expensive. I use pooltool python library, a solid open-source billiards simulator with accurate ball-cushion-pocket-felt interactions. A single shot takes ~5–15 ms to simulate end-to-end on one CPU thread for the typical 1–3 object-ball layouts that come up in shot evaluation; full racks (9 object balls) push that to ~20–50 ms because there are more pairwise collisions to track. Sounds fast until you do the math. For each layout I want candidate shots into 6 pockets, and each pocket has a 5-dimensional parameter space to search: speed, aim angle, elevation of cue stick, side spin, follow/draw. A naive grid sweep over even a coarse 10 steps per dimension is 100K combinations × 10 ms = ~17 minutes per pocket per decision. Iterative optimizers like CMA-ES bring that down to ~500–1000 sims per pocket, but that's still ~5–10 seconds per pocket, ~30–60 seconds per layout. For training a value network with millions of decisions, that's months of compute. Faster evaluation of candidates The shot selection needs to know if the shot will go without simulating every possible shot. But we don't need the final position of the table just yet. I approached the problem by splitting the shot into what the object ball needs to do and how to hit the cue ball to accomplish that. So the first component for shot making is an Acceptance window lookup. It is pre-computed offline per (object ball position, pocket, speed): the range of OB (object ball)-departure angles that actually drop the ball at different speeds into the selected pocket. This is the "what does the ball need to do" specification; it captures the pocket jaw geometry, the down-the-rail effect, all of it. Then I created a Shot-index lookup table. Given the desired OB-departure angle (measured as deflection from the cue-to-OB line) and the cue-to-OB distance, look up shots that produce that geometry from a pre-computed index using no elevation shots simulated using pooltool sampled on a discrete grid of (distance, speed, aim-offset, spin, draw) keyed by OB departure angle. Lookup returns candidate (speed, aim_offset, spin, draw) tuples that send the OB in the desired angle (distance is fixed by the layout). That was an improvement but it has holes due to discretization. To cover these holes, I built a throw model for continuous space generalization. It is a small MLP to predict OB-departure deviation given (cue→OB distance, speed, aim angle, spin, draw, elevation). It generalizes the shot-index data into the continuous space. Architecture is fairly straightforward. The features are aim_offset, distance, speed, side spin, draw and elevation. Output is deviation from cue-object ball angle. It has 4 hidden layers with 128 dimensions for hidden layers, ReLU activation, ~50k parameters in total. I trained the model over 5M shots (took about 6 hours to generate) and measured the Mean Angle Error over the validation set (~1.1M) which was around 0.2 degrees. I also used the left/right symmetry for the model to use 2x the data so I don't have to worry about taking care of mirroring during play. The beauty of it is that, I can use the shot index to get decent starting parameter set for shots and apply small perturbations across different parameters and evaluate them in a batch using the throw model on a GPU really fast. Speed up in my setup was around 10000x compared to simulating all those shots through the physics engine which makes a world of difference in generating enough self play data. Batch of 1000 candidate shots takes 1 ms to evaluate. Compare that to 1000 simulations x 10 ms on average. I then cluster all the shots that are predicted to fall within the acceptance window of the intended pocket using bucketing around speed, spin and draw. I evaluate representatives from each cluster using the physics engine using noisy simulation that adds execution noise to the shots. We don't want to find that 1-in-a-million shot that can't be executed reliably. Then I use the maximum expected value of the table state after the shot using the p(win) model (which I did not go into in this post) for shot selection. Given I still do physics simulations once I find my candidates, the end-to-end speedup was around 50-100x.

Local MCP server that tells Claude Code what would break before it edits a file (raysense, MIT, free)

A pattern I keep hitting in Claude Code: I ask the agent to refactor something modest -- a parsing utility, a helper, a config loader -- and the diff it produces looks fine. Tests in the file pass. I run CI and three unrelated tests blow up. Sometimes the broken caller is code I have not touched in months. The agent is not careless. It read the file. What it could not do was see the codebase: the dependency graph, the call sites, the modules that lean on each other, the cycles, the test coverage of each piece. Plain text never reveals this. You cannot grep your way to "what would break if I delete this function." We built raysense to close that gap. It is a single Rust binary + Claude Code plugin + stdio MCP server that gives Claude structural memory of your codebase. Free, MIT-licensed, local-only -- no SaaS, no API key, no telemetry. It ships from crates.io and builds from source on first install, so the only prerequisite is a Rust toolchain (cargo) on the machine. If you don't have it yet: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh After that, cargo install raysense is the whole installation. (Disclosure: I am part of the team behind it. Posting because the problem comes up on r/ClaudeAI a lot.) What it does raysense scans the repo and persists 27 small columnar tables under .raysense/baseline/tables/: call graph, imports, cycles, complexity, hotspots, drift over time. The MCP server exposes that database to Claude Code through typed tools, plus a plugin with six skills mapped to phases of the work: bootstrap at session start: scan, save baseline. impact before an edit: blast radius, coupling, cycle exposure. verify after an edit: diff vs. baseline, what newly broke. audit on demand: whole-repo sweep, dead code, hotspots. drift across time: what got worse over the last 30 days. query as escape hatch: free-form Rayfall query language. Claude does not get a 4000-line architecture report. It gets the answer to a structural question, scoped to whatever it is about to touch. Languages raysense reads 69 languages out of the box across three tiers of analysis depth, mirroring what's on the coverage map: 11 tree-sitter built-ins with full AST analysis: Rust, C, Python, TypeScript, C++, Java, C#, Kotlin, Scala, Swift, Ruby. The 9 class-based languages also get type-inheritance graphs. Rayfall (the RayforceDB query language) joins the same tier via native S-expression extraction. 57 catalog plugins covering Solidity, COBOL, Elixir, Go, PHP, Lua, Haskell, OCaml, Erlang, Clojure, Zig, Nim, Crystal, Julia, R, MATLAB, Bash, PowerShell, SQL dialects, etc. - function and import extraction via configurable prefix patterns, no AST. Every cross-cutting metric on this page (blast radius, edit-risk, drift, evolution, hotspots) works at every tier. What the agent sees A typical impact call before an edit: ``` impact src/scanner.rs src/scanner.rs blast_radius: 34 files (top 5: cli.rs, mcp.rs, memory.rs, ...) fan_out: 12 fan_in: 18 cycles: 0 upward_violations: none edit_risk: medium Test files nearby: 3. ``` One MCP call. Claude reads that answer and writes the diff with the right caution. On refactors where the blast radius came back larger than expected, Claude has changed direction mid-edit and asked us first. How we built it (with Claude Code) raysense is a Claude-Code-built project end to end. The pattern: write a slice plan, Claude implements most of the first pass, review and ask for corrections, Claude reruns tests and smoke checks until green. The interesting twist is that we self-host the tool inside the sessions that build it -- the impact skill runs on raysense's own files before Claude edits them, so the agent knows the blast radius of editing the scanner code it is itself working on. That loop has been the biggest accelerator on the project. Why local-first Structural memory of a codebase is sensitive. Every file path, function name, and module shape ends up in the database. Pushing that to a third-party server so an agent could query it was never on the table for us. The whole design assumes the substrate sits next to the source and is queried over a stdio pipe. Side benefit: re-querying a saved baseline is microseconds. Nothing leaves the machine. Try it The fastest path is the new raysense install command. It auto-detects which Claude hosts you have on the machine (Claude Desktop, Claude Code, or both) and wires raysense in as an MCP server in one shot. One-liner: bash curl -fsSL https://raw.githubusercontent.com/RayforceDB/raysense/main/install.sh | sh Step by step instead: bash cargo install raysense # binary only raysense install # register MCP with whichever Claude hosts are present Force a single host when you want to be explicit: bash raysense install --desktop # only Claude Desktop (edits claude_desktop_config.json) raysense install --code # only Claude Code (delegates to `claude mcp add`) Claude Desktop, concretely. raysense i

Dispatch up and running

With all the talk of OpenClaw and Hermes, I first wanted to test how good the dispatch beta is from Claude. Got it up and running on my Mac mini so it’s always on and a few initial observations. - surprisingly easier to setup than I thought - the big unlock is the Mac mini. It needs to be constantly on to really work - have all your documents on GitHub repo vs GitHub for code and Google/iCloud for docs (this gives it more context) -it needs success criteria. The more specific the better. This reduces the loops and sometimes it can get stuck -turn on computer use and give it the most aggressive permissions. It’s on a dedicated machine so relatively low risk with this setup I’m still looking at Hermes or OpenClaw, but initial testing says this is pretty good, and likely has gotten better the last few weeks quietly. If you tried it before, might be worth trying again. How is everyone using it? submitted by /u/ArcLabsAdmin [link] [comments]

Solo dev with 8 Claude windows + 1 orchestrator. AMA-ish, and tell me if I'm crazy.

Hey everyone, I'm not a senior engineer. I'm just a guy who got obsessed with what you can actually do when you stop using one AI at a time and start running a small team of them. Am doing a project where i use 8 to 10 claude code powershelle to run my project each of them have a specific function. I have Claude max 200 euros so I can use a lot of power. ight now I have 9 Claude Code windows open at the same time, each with a defined role: Major Dev — lead developer, makes the architectural calls Senior Dev — second dev, builds components and tests under Major Dev's direction Test Server — keeps the dev server alive 24/7 + runs Playwright Implémenter — handles routing and the glue code between features Débuggage — audits warnings, fixes bugs in parallel QA — walks through every screen, tests every button, checks WCAG/accessibility Graphisme — generates 2D assets (avatars, hero images, badges, mockups) Ingé Son — generates ambient music + SFX prompts (Suno) Idea Extender — I throw it raw ideas, it expands them and produces 2 ready-to-paste briefs (one for Major Dev, one for Senior Dev) Doing a project rn where I teach kid how to use Ai and how to learn with Ai. If anyone has tried something similar, I'd love to know: - How do you handle the orchestrator going down? - Do you let agents talk peer-to-peer, or always through a manager? - How do you split work between a "lead" agent and "execution" agents? Happy to share the protocol files if people are interested. submitted by /u/KamomiIIe [link] [comments]

Why v2 of my trading system strips the LLM of its execution rights (Blueprint & Architecture)

Thanks to the incredible feedback on my last post, I’m officially moving away from the "distributed veto" system (where 8 LLM agents argue until they agree to trade). For v2, I am implementing a strict State Machine using a deterministic runtime (llm-nano-vm). ​The new rule is simple: Python owns the math and the execution contract. The LLM only interprets the context. ​I've sketched out a 5-module architecture, but before I start coding the new Python feature extractors, I want to sanity-check the exact roles I’m giving to the AI. Here is the blueprint: ​1. The HTF Agent (Higher Timeframe - D1/H4) ​Python: Extracts structural levels, BOS/CHoCH, and premium/discount zones. ​LLM Role: Reads this hard data to determine the institutional narrative and select the most relevant Draw on Liquidity (DOL). ​2. The Structure Agent (H1) ​Python: Identifies all valid Order Blocks (OB) and Fair Value Gaps (FVG) with displacement. ​LLM Role: Selects the highest-probability Point of Interest (POI) based on the HTF Agent's narrative. ​3. The Trigger Agent (M15/M5) ​100% Python (NO LLM): Purely deterministic. It checks for liquidity sweeps and LTF CHoCH inside the selected POI. ​4. The Context Agent ​LLM Role: Cross-references active killzones, news blackouts, and currency correlations to either greenlight or veto the setup. ​5. The Risk Agent ​100% Python (NO LLM): Calculates Entry, SL, TP, Expected Value (EV), and position sizing. ​The state machine will only transition to EXECUTING if the deterministic Trigger and Risk modules say yes. The LLMs are basically just "context providers" for the state machine. ​My questions for the quants/architects here: ​Does this division of labor make sense? Am I giving the LLMs too much or too little responsibility in step 1 and 2? ​By making the Trigger layer (M15/M5) 100% deterministic, am I losing the core advantage of having an AI, or is this the standard way to avoid execution paralysis? ​Would you merge the HTF and Structure agents to reduce token constraints/hallucinations, or is separating them better for debugging? ​Would love to hear your thoughts before I dive into the codebase. submitted by /u/Simone_Crosta [link] [comments]

Four months building with Claude: a diagnostic framework for American constitutional history

Sharing a project I built with Claude over four months. Free to try, no signup, runs in the browser: https://www.papercutslibrary.com/explore/constitutional-reality-framework/ It's an interactive learning module that maps 236 years of American constitutional history onto a two-dimensional analytical grid measuring accountability and proactivity by branch. The goal: let people see how American constitutional power has actually behaved over time, not how civics class describes it. https://preview.redd.it/56v5y0egx4yg1.png?width=1354&format=png&auto=webp&s=9cbcb6aa3499ab8b8a378b411447e2f1dbd21ae0 I want to be clear about what the collaboration actually looked like, because I think that's the more useful conversation. How the framework came to be. This started as research on the Supreme Court. I noticed the 1937 switch in time and wanted to track the kind of institutional movement it signaled. The framework idea emerged from that. Early work was one-off mappings and thematic analysis, building the framework's two-dimensional logic by testing it against specific cases. At some point I got the idea of mapping the full sweep of American history through it, and a two-month grind to produce the learning module began. The initial idea was much smaller than what it became. The framework grew, and so did the scope, through the process. I wrote a short book on AI arguing that one of its most important practical uses could be helping people level-set reality, particularly during periods of heavy misinformation. This project applies that idea to history, through a diagnostic framework. Claude wouldn't have proposed any of that. The originating ideas and the module's design are mine. What Claude contributed. Almost all of the historical and editorial content. I'm not a historian. Producing 29 mapped eras with placement-level evidence across 236 years was beyond what I could do alone. The work depends on AI's handle on historical context, and the info modal in the tool is explicit about this. I'm also not a coder. I have enough past programming experience to follow what I'm looking at, but I did not write a single line of code in this build. I reviewed specs and briefs, ran tests, and made architecture decisions. One day I spent four hours getting four captain threads to agree on a re-architecture brief. The code itself is Claude's work. The framework documentation grew complex enough that I couldn't track every internal consistency point either. Claude tracked it. I directed it. How I structured the work. Multi-thread architecture, with specialized Claude threads running in parallel: • Project Captain: coordination and sequencing • Design Captain: UI decisions • Editorial Captain: voice and style standards • Era/Audit Captain: placement integrity across the timeline • Editorial Execution and Editorial Review: separate drafting and review threads The roles weren't strict walls. Project Captain wrote and coded when needed. The discipline was in the processes between threads: editorial runs, placement setups, structured handoffs. Over a hundred briefs and specs moved between threads across four months. That structure is what kept the work coherent and prevented the drift that happens when a single context handles everything. Captains had to be retired when context degradation set in. That was a constant challenge. The methodology I held to throughout: batch tasks, take time with everything, prefer high-quality results over speed. All 29 maps went through an execution and review cycle against a dedicated style guide. Every placement is backed by tiered evidence (Tier 1 primary sources, Tier 2 secondary), documented with explicit confidence levels. Coding. The build itself ran through the same structured pattern. Captains wrote briefs and prompts for Cowork to do work on the modular codebase. Cowork was given a verification checklist in most cases, and the associated Captain would review the standalone HTML build that resulted. The current build is nearly 15,000 lines in a 1.6MB single standalone HTML file, which is what's online. Cross-model verification. Recent events fall past Claude's training cutoff, so I used GPT and Gemini for independent verification through systematic web research. One unexpected finding worth reporting: some 2026 developments, particularly recent military actions, were so far outside the other models' priors that they flagged them as likely hallucinations. They weren't. The events were just genuinely unprecedented. Validating that gap was its own piece of work. Disclosure. Full AI collaboration disclosure is in the tool's info modal. Claude (Opus and Sonnet, 2025 to 2026) for the analytical and editorial work. CC BY-NC-SA 4.0. Try it: https://www.papercutslibrary.com/explore/constitutional-reality-framework/ submitted by /u/papercutslibrary [link] [comments]