Socket

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Socket AI

Experimenting with a 4-Agent Local Dev Team (Claude Code). Hitting IPC & token walls managing shared folders vs. private repos. How do you handle communication?

Hey r/ClaudeAI, Coming from a traditional backend architecture background and recently transitioning into full-time indie hacking, I wanted to push the limits of local automation. I’m currently running a localized multi-agent experiment using Claude Code to build a complete project. It's fascinating, but I've hit some frustrating bottlenecks. Following the general consensus to keep agents single-minded rather than using one massive monolithic prompt, I’ve spun up four separate Claude Code instances on my machine. Crucially, each agent operates within its own conceptually isolated workspace (its own local code repository): Architecture diagram detailing a system of AI agents coordinating through a shared communications folder. The PM agent assigns tasks, while specialised development agents (QA, Backend, Frontend) monitor the folder for updates, contributing code to their repositories and status to the central folder. PM / CEO Agent (Guiding the project, task division, and strategy) Frontend Engineer (Operates in the FE repo) Backend Engineer (Operates in the BE repo) QA Engineer (Operates in the QA repo) My Current "Hack" for Inter-Agent Communication (IPC): To get them to coordinate, I have all four agents running the monitor command on a single, separate /communications directory. Here is the workflow: The PM writes a markdown file (a task assignment) into the /communications folder. The Frontend Agent's monitor picks up the file change and reads the task. The Frontend Agent then switches focus to its own isolated workspace (the FE Repo) to actually write the code. Once finished, the Frontend Agent writes a status report markdown file back into the shared /communications folder for the PM or QA to pick up. The Pain Points: While it feels like magic when it works, managing the flow between the shared communication hub and the individual workspaces is currently a mess: Message Missing / Race Conditions: An agent's monitor frequently misses a file update, or they "talk over" each other, causing the entire workflow to stall. Coordination Overload & Token Hemorrhage: Agents burn a massive amount of tokens just monitoring the shared folder for changes. When they do find a task, the constant context-shifting—reading the shared communications folder, jumping into their own local repos to write code, and jumping back to write a status report—causes token consumption to go absolutely astronomical. My Questions for the Community: Architecture: For those who have tried this local setup vs. Claude Code’s official "Teams" mode—what are the fundamental differences in underlying logic? Is "Teams" natively better at coordinating between a shared context and isolated code repos? Or is it just doing the exact same file-watching hack under the hood? Coordination Protocols: Does anyone have a more elegant, stable solution for inter-agent coordination? Are you using local webhooks, socket connections, or specific file-handling patterns to reduce token waste and prevent dropped messages (especially when agents need to maintain their own separate codebases)? Would love to hear your thoughts or see your local multi-agent setups! Attached a quick diagram of my current messy architecture below. submitted by /u/Ok_Competition_2497 [link] [comments]

Agentic Infrastructure

I was planning on deploying Splunk or some other server monitoring software, but instead I decided to deploy an agent per server to collect telemetry and report back. The interesting bits: (1) every "service" is a claude-code session — the router, every per-host monitor, the dashboard tile poller. They route to each other via a WebSocket hub. (2) Watchers that detect host events are plain bash (cheap, near-zero idle cost); the LLM only wakes for the drain cycle every 5 minutes. (3) Operator's dashboard is a tile registry where each tile is just a saved natural-language question (e.g., "disk % across all monitors") that gets re-fired against the router on schedule and cached in SQLite. (4) When something breaks, the agents diagnose it themselves and the alert in Slack arrives with context, not just disk >= 80%. submitted by /u/fixitchris [link] [comments]

Hands-free voice trigger & control multiple Claude Code Agents.

Hey guys, I run several Claude Code always-on agents and I wanted a way to trigger & control each one separately across my local network through my airpods, so I built voice-channel. It's a Claude Code Channel plugin with a dispatcher that you setup on your laptop. It allows you to trigger multiple Claude Code instances like: "hey Atlas, what is the status of gh issue 1", or "Hey Hermit, what is next on the task list" and Claude answers back. When you are running 8+ AI assistants across your local network it's really useful. You setup a trigger phrase like "Hey Atlas" for each Claude Code instance and whatever you say next routes that command into the specific running agent across the local network, each agent has it's own name, trigger phrases etc. The architecture is intentionally small: Host Python dispatcher owns mic, speakers, VAD, STT, and TTS Bun/TypeScript Claude Code Channel plugin connects to it over WebSocket like Discord & Telegram & Imessage official channel plugins local Whisper/Piper by default designed for local Claude Code agents, not as a generic Alexa clone Repo: https://github.com/gtapps/voice-channel Would love feedback from macOS users to see if it's fully compatible as I wasn't able to test there. submitted by /u/dnationpt [link] [comments]

Built a free self-hosted web terminal interface for Claude Code CLI

https://github.com/HalfLucid/Claude-Code-Cli-WebTerminal I like using claude code CLI from my phone sometimes but I had issues with the method I was previously using (tailscale + termius) and decided to make something that works better for me. Sorry Windows only at the moment but feel free to fork/copy do whatever you want. I just wanted to share what I made in case someone else would like to use it too. Built this using claude code just specifying what I wanted If you do like it or have any feedback for things I should add let me know. Screenshots are in the github page. Would love to hear what you think. -- Browser-based terminal over WebSocket with persistent, multi-tab sessions. Built for running Claude Code from any device — including mobile. ASP.NET Core minimal API backend + xterm.js frontend. Connects your browser to a real PTY (pseudo-terminal) on the host machine. Features Persistent sessions — PTY stays alive through disconnects, screen sleep, network loss. Reconnect and pick up where you left off. Multi-tab — run multiple shells or Claude Code instances side by side with a tabbed interface. Claude Code integration — launch Claude Code directly into any configured project directory. Open new or resume existing sessions. Mobile-friendly — touch-optimized button overlay with configurable keys (Enter, arrows, Ctrl combos, Esc, Tab, etc.) and paginated layout. Native text input — uses a virtual text entry layer that preserves your device's autocomplete, swipe typing, dictation, and IME support. Edits are transparently bridged to the PTY, so the full mobile keyboard experience works naturally in the terminal. Session ring buffer — 256KB buffer replays recent output on reconnect so you never lose context. Basic auth — credentials set on first run, encrypted with Windows DPAPI. Startup toggle — optional Windows startup registration from the main screen. Configurable buttons — reorder built-in buttons, switch Claude model/effort, and create custom buttons that send any text to the terminal. Custom buttons can trigger slash commands (e.g. /review), full prompts (e.g. summarize all changes, commit, and create a pull request), or any terminal input. Usage PowerShell — click "PowerShell" on the main screen to open a shell tab Claude Code — add a project (name + directory), then use "Open Claude" or "Resume Claude" Tabs — use the + button to open more sessions, click tabs to switch Mobile — tap the arrow button on the right edge to expand the button overlay for touch-friendly input Remote access — access from other devices on your network at http:// :7681 (works great with Tailscale) Custom Buttons The button overlay on the right side is fully configurable via the Buttons settings on the main screen. Reorder — move any built-in button up or down to change its position Model / Effort — built-in popout buttons to switch Claude's model (opus, sonnet, haiku) or effort level Custom buttons — add your own buttons with a label and a command string Custom button commands are sent directly to the terminal as text input, so they work with anything the active shell or CLI accepts. Examples: Label Command What it does Review /review Triggers Claude Code's review skill Compact /compact Compresses Claude Code context Commit summarize all changes, commit, and create a pull request Full natural language prompt sent to Claude Code Status git status Runs a git command in a PowerShell tab submitted by /u/halflucids [link] [comments]

Vibe coded an algorithm that prints money

Been quietly working on this for the past year. tried to write it by hand at the start but decided to do 90/10 vibe code because it was too much work for a simple person. The idea is simple: Binance announcements move markets instantly and violently. The edge is being first (and the hardest part of the project). The system detects announcements the moment they hit, classifies them in sub microsecond, and simultaneously fires orders on multiple exchanges. It runs 24/7 on a dedicated AWS server in Tokyo,took a lot of painful lessons with exchange APls, WebSocket quirks, and latency optimization to get here but it's been worth it. Here is some examples of profits (| started with very small amount and added very slowly). Couldn't have done it without codex/claude code so yeah... This is obviously not a financial advice ! Just wanted to share something I have been building submitted by /u/Agreeable_Split1355 [link] [comments]

Inter-1 does streaming: real-time social signal detection from live video, audio & text

Hi – Filip from Interhuman AI here 👋 Last month we launched Inter-1, our multimodal model for detecting social signals from video, audio, and text. Today we’re making it work with video streams. We just released the Inter-1 Streaming API: a WebSocket endpoint that runs the full Inter-1 stack - 12 social signals, structured rationales, engagement, and conversation quality on live video while the conversation is unfolding. You stream WebM chunks in, and get back regular updates with detected signals. The model runs in sliding 8s windows with a sub-1.0 processing ratio, so it’s fast enough to power live coaching prompts, in-call overlays, and adaptive UI. It’s not meant to be a full voice agent on its own, it’s the behavioral signal layer you plug under whatever interaction system you’re building. If you’re working on sales/CS tooling, interview coaching, training, or live feedback products and want to experiment with real-time social intelligence, it might be worth looking into. Happy to answer questions or brainstorm use cases in the comments. submitted by /u/Sardzoski [link] [comments]

Claude suggesting me to sleep at 1:32 pm!!!

https://preview.redd.it/uf1cdhusb52h1.png?width=1413&format=png&auto=webp&s=f06a2790165a9a618cc67dca7dfd7f8b1af7c5ff Not a power nap, a good night sleep! :D ..............take it as humor not complaining! submitted by /u/clawvault [link] [comments]

I built a tool that shows you what GPT-2 is "thinking" in real-time as it generates 3D graph of concept activations per token [R]

Been going down a mechanistic interpretability rabbit hole for the past few weeks and ended up building this thing called AXON. The idea: every time GPT-2 generates a token, its residual stream gets passed through a Sparse Autoencoder (Joseph Bloom's pretrained SAE). The SAE decomposes it into human-interpretable feature: hings like "European geography", "capital cities", "French language" and streams those to the browser over WebSocket, where they show up as a live 3D force graph. Nodes = SAE features. Edges = features that fired together on the same token. Node brightness = activation strength. The whole graph evolves token by token. What surprised me most: type "The capital of France is" and you can literally watch geography features, proper noun features, and completion-pattern features light up before the word "Paris" even gets generated. It's not what the model outputs that's interesting it's what's happening right before it decides. Stack: TransformerLens + SAELens on the backend, FastAPI WebSocket for streaming, Three.js + 3d-force-graph on the frontend. Runs on CPU (~800ms/token) or GPU (~35ms on a 4050). Labels come from Neuronpedia's API and get cached locally. You can also swap in other models — GPT-2 medium/large/xl, Pythia variants, Gemma-2-2B — as long as there's a pretrained SAE for it in SAELens. GitHub: https://github.com/09Catho/axon Would love feedback and stars especially from anyone who's worked with SAEs before curious whether the co-activation edges are actually meaningful or just noise at this layer. submitted by /u/Financial_World_9730 [link] [comments]

9 things about Claude I wish someone had told me 10 years ago

Be specific with context — Instead of "fix this," say "fix the race condition in the WebSocket reconnect logic." The more precise your request, the better my output. Show me the code first — I work best when I've read the relevant files. Open them or reference them so I have real context, not assumptions. Break big tasks into steps — Instead of "refactor the entire auth system," ask me to handle one piece at a time. You'll get more accurate results and can course-correct early. Challenge my output — I can be confidently wrong. If something feels off, ask me to explain my reasoning or double-check with "are you sure about X?" Use me for exploration — Ask "how does this work?" or "what are the tradeoffs between A and B?" before jumping into implementation. I'm good at research. Give me constraints — "Use no external libraries," "keep it under 50 lines," "match the existing pattern in utils/" — constraints produce better code. Iterate, don't restart — If my first answer is 80% right, tell me what's wrong rather than rephrasing from scratch. I learn from corrections within the conversation. Let me run things — I can execute commands, run tests, and check errors. This feedback loop catches mistakes I'd otherwise miss. Don't over-explain obvious things — I already know TypeScript, React, common patterns, etc. Spend your words on what's unique to your project (business logic, conventions, edge cases). submitted by /u/ambient_lizard [link] [comments]

How I used Claude Code (and Codex) for adversarial review to build my security-first agent gateway

Long-time lurker first time posting. Hey everyone! So earlier this year, I got pulled into the OpenClaw hype. WHAT?! A local agent that drives your tools, reads your mail, writes files for you? The demos seemed genuinely incredible, people were posting non-stop about it, and I wanted in. I had been working on this problem since last year and was genuinely excited to see that someone had actually solved it. Then around February, Summer Yue, Meta's director of alignment for Superintelligence Labs, posted that her agent had deleted over 200 emails from her inbox. YIKES. She'd told it: "Check this inbox too and suggest what you would archive or delete, don't action until I tell you to." When she pointed it at her real inbox, the volume of data triggered context window compaction, and during that compaction the agent "lost" her original safety instruction. She had to physically run to her computer and kill the process to stop it. That should literally NEVER be the case with any software ever. This is a person whose actual job is AI alignment, at Meta's superintelligence lab, who could not stop an agent from deleting her email. The agent's own memory management quietly summarized away the "don't act without permission" instruction, treated the task as authorized, and started speed-running deletions. She had to kill the host process. That's when I sort of went down the rabbit hole, not because Yue did anything wrong, but because the failure mode was actually architectural and I knew that in my gut. Guess what I found? Yep. Tons more instances of this sort of thing happening. Over and over. Why? Because the safety constraint was just a prompt. It's obvious, isn't it? It's LLM 101. Prompts can be summarized away. Prompts can be misread. Prompts are fucking NOT a security boundary. And yet every agent framework I have ever seen seems to be treating them as one. I went and read the OpenClaw source code, which I should have done to begin with. What I found was a pattern I think a lot of agent frameworks have fallen into: - Tool names sit in the model context, so the model can guess or forge them - "Dangerous mode" is one config flag away from default - Memory management has no concept of instruction priority - The audit story is mostly "the model thought it should" I went looking for a security-first alternative I could trust, anything that was really being talked about or at a bare minimum attempted to address the security concerns I had. I couldn't find one. So I made it myself. CrabMeat is what came out of that, what I WANTED to exist. v0.1.0 dropped yesterday. Apache 2.0. WebSocket gateway for agentic LLM workloads. One design thesis: The LLM never holds the security boundary. What that means in code: Capability ID indirection. The model doesn't see real tool names. It sees per-session HMAC-derived opaque IDs (cap_a4f9e2b71c83). It can't guess or forge a tool name because it doesn't know any tool names. Effect classes. Every tool declares a class (read, write, exec, network). Every agent declares which classes it can use. The check is a pure function with no runtime state, easy to test exhaustively, hard to bypass. IRONCLAD_CONTEXT. Critical safety instructions are pinned to the top of the context window and explicitly marked as non-compactable. The Yue failure mode, compaction silently stripping the safety constraint, cannot happen by construction. The compactor literally cannot touch them. Tamper-evident audit chain. Every tool call, every privileged operation, every scheduler run enters the same SHA-256 hash-chained log. If something happens, you can prove what happened. If the chain is tampered with, you can prove that too. Streaming output leak filter. Secrets are caught mid-stream across token boundaries, capability IDs, API keys, JWTs, PEM blocks redacted before they reach the client. No YOLO mode. There is no global "trust the LLM with everything" switch. There never will be. Expanded reach comes through named scoped roots that are explicit, audit-logged, and bounded. The README has 15 'always-on' protections in a table. None of them can be turned off by config, because these things being toggleable is how the ecosystem ended up where it is. I decided to make sure that this wasn't just a 'trend hopping' project and aligned with my own personal values as well. I built this to be secure and local-first by default. Configured for Ollama / LM Studio / vLLM out of the box. Anthropic and OpenAI work too but require explicit configuration. There is no "happy path" that silently ships your prompts to a cloud endpoint. I decided that FIRST it needed to only run as an email agent with a CLI. Bidirectional IMAP + SMTP with allowlisted senders, threading preserved, attachments handled. This is the use case that bit Yue and a lot of other people, and I wanted to prove it could be done with real boundaries. I added in 30+ built-in tools of my own. File ops, shell (denylisted, output-capped, CWD-lo

Solo indie game developer, new grad no formal SWE experience in love with how productive Claude has made me

My game has gone through a few iterations at this point, but Claude, specifically Claude Code has been game changing for me. Started in the desktop app with 3.5 haiku, now on the max plan with Claude Code. I'm interested to hear from other recent college grads that have built something with these new coding tools. I don't know how much of my project I should attribute to Claude Code, my education, my sheer persistence, or all of the above. Not saying my game is bullet proof BY ANY MEANS, but it's WAY more than I would've ever been able to build without CC. Basically 100% of the code has been written with Claude Code, or copying and pasting over from Claude's desktop app before Claude Code was a thing. Some highlights of what Claude helped me out with: - No wasting time reading syntax docs for libraries, understand what libraries function is -> implement - Real-time multiplayer up to 10 players per lobby - Cost-optimized serverless GPU autoscaling (minimizing GPU costs) - Mobile first phone as controller UX like Jackbox, or Kahoot -Mobile browser socket connection troubleshooting -R2 bucket policy deletes prompts and images daily -Open source image model, presented cold start challenges 6 months ago I was a new grad with no SWE experience. Today I'm running https://imageclash.net. It's real-time multiplayer party game focused on creative, comedic, AI image generation in a competitive format (think Cards against humanity with AI images). Players create prompts → AI generates images → everyone votes on the funniest ones. Just wanted to share because Claude Code is genuinely incredible for solo builders with limited experience. This project would have been impossible for me on my own, and it has always been my dream to build games submitted by /u/Dsc_004 [link] [comments]

Heren Godot MCP — Fast, powerful, simple. (+Benchmarks!)

There are already a few great MCP servers that connect AI assistants to the Godot engine. Heren takes a different path: instead of starting a fresh Godot process for every request, it keeps a lightweight WebSocket daemon running in the background. Once launched, the engine stays alive and responsive, so the AI can interact with your project almost instantly! This seemingly small shift makes a HUGE difference in practice: · Operations complete in around 20ms rather than waiting for a full engine cold start. · Because Godot remains alive, sub‑resources like collision shapes, materials, and environments are fully persisted in your scene files – something that’s tricky to get right with ephemeral processes. · Signal connections, batch operations, and script editing all feel smooth and consistent, without the “stop‑and‑go” rhythm of launching and quitting the engine repeatedly. · A built‑in debug system gives the AI access to breakpoints, stack traces, watch variables, and console output, so it can help you troubleshoot in real time. · GPU‑accelerated screenshots let the AI literally see the viewport and real-time coordinates, which is incredibly handy for visual feedback. · The daemon shuts itself down automatically after three minutes of inactivity, so it’s gentle on resources. All of this is built through 15 carefully designed tools that cover scene management, nodes, resources, scripts, shaders, animations, validation, and debugging. The project is open source, completely free, and bilingual (English/Spanish). They said "here be dragons", because they were afraid of their power! 🐉 submitted by /u/Lordddddddy [link] [comments]

I built a sidebar for Claude Code: every prompt clickable, jumps the terminal back to that turn

The why: I run Claude Code in a tmux session on a Linux dev box, SSH'd in from a Windows laptop. The terminal-only flow worked, but I wanted three things tmux alone doesn't give me — clickable prompt history, a file panel next to the terminal so I stop cat-ing things to look at them, and push notifications when Claude is waiting for me without staring at the tab. Existing tools each solve one slice (ttyd = terminal only, filebrowser = files only, code-server is VS Code-shaped and heavy). I wanted them in one page, on every device. Started as a weekend project, ended up as my daily driver. What it is: a single Go binary on your dev box. SSH-tunnel into 127.0.0.1:8080: xterm.js terminal, tmux-backed (survives disconnects, sleeps, server restarts) File tree (preview, drag-drop upload, follows your cd via tmux's pane_current_path — no shell integration needed) Activity panel reads ~/.claude/projects/*.jsonl and shows every prompt. Click one → terminal scrolls back to that turn. Same for Top-bar chips for active model + latest context tokens Push notifications via Claude Code's Stop hook (laptop pings when Claude is idle, even with tab backgrounded) Design decisions worth sharing: tmux is the durability layer. Every session is tmux new-session -A -s {id}. Shell survives WS disconnect, server restart, idle timeout because tmux already solved that. roost owns the WebSocket bridge and an append-only disk log — that's it. Single-user-per-instance, forever. I refuse to add accounts/RBAC. Two people share a host? Each runs their own roost serve on a different port. UNIX UIDs handle isolation. Multi-tenant logic belongs in a reverse-proxy, not the binary. Kept the auth code under 100 lines. Vanilla JS, no build step. Frontend is plain files under //go:embed all:web. No bundler. Easier to debug, easier to ship, lower future cost. One bug worth flagging: tmux's display-message -p '#{x}\x1f#{y}' returns 0x1f as literal _ when tmux is launched without a UTF-8 locale (systemd / launchd units, for example). Burned an hour on this before realising tmux -u is the one-line fix. If you ever pipe tmux through field separators, lock the locale. Validated combo right now: Linux server + Windows Chrome over SSH tunnel. macOS-as-server works but has rough edges. Codex sessions work too if you swap agents. Repo + GIF demo: https://github.com/liamsysmind/roost v0.1.0 tarballs: https://github.com/liamsysmind/roost/releases/tag/v0.1.0 If you drive Claude Code over SSH — what's missing for you? submitted by /u/Adventurous_Sun9149 [link] [comments]

I tested GPT-5.5 Codex against Opus 4.7 Claude Code, and it's about time Anthropic bros take pricing seriously.

I've used Claude Code the most among AI coding agents. Sonnet, Opus, I've run them all. The reason is simple: they're beasts at tool execution and prompt following. That's also why Anthropic dominates API revenue from code agents. First-mover advantage is real, and developers love them. But GPT-5.5 Codex has been insanely good. When new models drop, I run real tests, not benchmarks. This time I built two tasks: Test 1: PR triage bot – GitHub MCP, scoring formula, Slack alerts, retries, strict TS, no "any". Test 2: Real-time code review UI – React, WebSockets, optimistic rollback, virtualized diff, WS reconnect. Same prompts. Same MCP (GitHub + Slack). Same machine. Here's what I found out: Claude Code (Opus 4.7): - Verified MCP before writing a line - Built 36 files in 12 minutes - Wrote its own WebSocket smoke test (3ms broadcast) - Zero errors first run - Total cost: ~$2.50 Codex (GPT-5.5 via Cursor): - Failed Task 1 (GitHub MCP not reachable – Cursor environment issue, not model) - Task 2 shipped but needed a patch for infinite React loop - 28 files, more compact architecture - Total cost: ~$2.04 (18% cheaper) Claude shipped cleaner. Codex needed a patch pass. For complex, architecture-heavy work, I still reach for Opus – no question. But Codex was leaner, cheaper, and open source. For tight, self-contained tasks where you want to ship fast – Codex holds its own. I'm not switching. But for the first time, I'm watching the pricing gap. Full breakdown with all code, prompts, run logs, and cost tables: https://composio.dev/content/claude-code-vs-openai-codex submitted by /u/geekeek123 [link] [comments]

RT @SocketSecurity: 🐘 @packagist is urging #PHP projects to update Composer after a GitHub token format change caused some GitHub Actions t…

RT @SocketSecurity: 🐘 @packagist is urging #PHP projects to update Composer after a GitHub token format change caused some GitHub Actions t…