Pi

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Pi AI

Ambient “manager” with Claude Haiku — one unsolicited line, rich context, no chat UI

I built a minimal ambient AI pattern for my home desk setup: don’t open a chat — still get one short, timely line based on real context. What feeds the model (high level): Notion task state + estimates, calendar, biometrics/wellness signals, desk presence / away-ish cues from my home stack, plus schedule timing. The UI is a Pi + touchscreen bar display running a dashboard; the “agent” is mostly one line of text at the bottom, not a conversation thread. Why Haiku: I want this to fire often without feeling heavy — fast/cheap enough to be “always there,” more like a status strip than an assistant window. Examples I actually get: On task start: a tiny pre-flight habit nudge (e.g., drink water first). On task completion with slack before the next meeting: a gentle “you have time — maybe a walk.” Late night: a firm boundary push (“ship it to tomorrow; protect sleep”). As a freelancer, the surprising outcome wasn’t “smarter text” — it was social texture: something that behaves a bit like a good manager — aware of context, not omniscient, not chatty. Tech-wise: Claude Haiku for generation, Node services behind the scenes, Notion as task source of truth, plus sensors/integrations for context. Happy to go deeper on architecture / pitfalls (latency, safety, “don’t nag”) if people are building something similar. submitted by /u/tsukaoka [link] [comments]

I resurrected LavaPS - a Linux process monitor from 2004 that died when GNOME2 did. Running on a robot car.

LavaPS displays every running process as a bubble in a lava lamp — bigger = more memory, faster rising = more CPU. Written by John Heidemann in 2004. Died around 2012 when libgnomecanvas was deprecated. We ported it to GTK3 + Cairo. The blob physics, process scanning, and color logic were solid — just the rendering layer needed replacing. Source: https://github.com/yayster/lavaps-modern Full video (with demo): https://youtu.be/cWBE4XkmNyQ This is Episode 2 of Picar — an AI riding around in a robot car on a Raspberry Pi 5. submitted by /u/yayster [link] [comments]

I built a `/focus` command for Claude Code — instant context loading from persistent memory

I've been building AI-IQ, a persistent memory system for AI agents. Just shipped v5.7.0 with a new `focus` command and submitted it to the Claude Code plugin marketplace. **The problem:** Every Claude Code session starts fresh. You waste the first few minutes explaining what you were working on. **The fix:** `memory-tool focus "my-project"` instantly loads: - Relevant memories (hybrid search: keyword + semantic + graph) - Knowledge graph entities, facts, and relationships - Open predictions and beliefs - Pending TODO items - Suggested next actions It's like a "previously on..." recap for your AI. **How it works:** - Single SQLite file = your AI's brain - No cloud, works offline - `pip install ai-iq` - Also submitted as a Claude Code plugin — install with `/plugin marketplace add kobie3717/ai-iq` Other features: beliefs with confidence scores, predictions you can resolve over time, knowledge graphs, dream mode (AI memory consolidation), FSRS-6 spaced repetition for natural memory decay. GitHub: https://github.com/kobie3717/ai-iq PyPI: https://pypi.org/project/ai-iq/ submitted by /u/kobie0606 [link] [comments]

Built a skill extraction API in public, then wrapped it in MCP, the developer experience difference is massive

Quick backstory, I've been building Loreto in public over the past few weeks. Started as a REST API that extracts structured skill packages from content sources (YouTube videos, articles, PDFs, images). The API worked, the Python SDK worked, but the workflow still felt clunky. You'd generate skills, then manually move files around, then hope Claude picks them up correctly. Last week I realized MCP was the missing piece. Instead of treating skill generation as an external API call, why not bring it directly into Claude Code as a native tool? So I wrapped the API in a FastMCP server and published it to PyPI. The difference is night and day. Before: run a script, copy output files, organize into folders, restart Claude. Now: "Use Loreto to extract skills from this video and save them to .claude/skills/"... done. Claude calls the tool, gets the skill packages back, writes them to disk, and immediately starts applying them on future tasks. What actually comes out of this: I pointed it at a few technical video on hybrid AI architecture and other concepts and got 9 distinct, production-quality skills. Unedited outputs here, browse through and see for yourself: github.com/kopias/loreto-mcp/tree/main/sample-skills A few that get real use in my projects: temporal-reasoning-sleuth — teaches Claude how to trace decision chains across long event timelines diagnosing-rag-failure-modes — identifies and fixes the 7 most common RAG pipeline failures designing-hybrid-context-layers — patterns for combining vector search, graph traversal, and structured data Each skill includes a SKILL.md with principles and failure modes, a README, reference files, and a test script. They're not summaries but rather deep enough that Claude applies them meaningfully across different codebases. The part that actually matters: Once a skill lives in .claude/skills/, Claude Code loads it automatically on relevant tasks. No re-prompting. No "hey remember that pattern I told you about." The knowledge persists across sessions. Over time you're building a library of reusable expertise that compounds, each video or article you process makes the agent permanently better at something. Setup takes about 2 minutes: pip install loreto-mcp Add to ~/.claude/mcp.json: { "mcpServers": { "loreto": { "command": "uvx", "args": ["loreto-mcp"], "env": { "LORETO_API_KEY": "lor_..." } } } } Then just talk to Claude normally: "Use Loreto to extract skills from [URL] and save them to .claude/skills/" Free tier is 5 calls/month and each call returns up to 3 skills, so that's potentially 15 skills per month before you need to upgrade. Repo: github.com/kopias/loreto-mcp API key: loreto.io Going from API → MCP was one of those "why didn't I do this sooner" moments. If you're building tools for AI agents, seriously consider the MCP route first, the developer experience is on another level when the tool lives inside the agent's own workflow. Happy to answer questions or hear what others are building in public. submitted by /u/Classic_Display9788 [link] [comments]

TIL Anthropic's rate limit pool for OAuth tokens is gated by... the system prompt saying "You are Claude Code"

I've been building an LLM proxy that forwards requests to Anthropic using OAuth tokens (the same kind Claude Code uses). Had all the right setup: Anthropic SDK with authToken All the beta headers (claude-code-20250219, oauth-2025-04-20) user-agent: claude-cli/2.1.75 x-app: cli Everything looked perfect. Haiku worked fine. But Sonnet? Persistent 429. Rate limit error with no retry-after header, no rate limit headers, just "message": "Error". Helpful. Meanwhile, I have an AI agent (running OpenClaw) on the same server, same OAuth token, happily chatting away on Sonnet 4.6. No issues. I spent hours ruling things out. Token scopes, weekly usage (4%), account limits, header mismatches, SDK vs raw fetch. Nothing. Finally installed OpenClaw's dependencies and read through their Anthropic provider source (@mariozechner/pi-ai). Found this gem: // For OAuth tokens, we MUST include Claude Code identity if (isOAuthToken) { params.system = [{ type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude.", }]; } That's the entire fix. The API routes your request to the Claude Code rate limit pool (which is separate and higher than the regular API pool) based on whether your system prompt identifies as Claude Code. Not the headers. Not the token type. Not the user-agent string. The system prompt. Added that one line to my proxy. Sonnet works instantly. This isn't documented anywhere in the SDK docs or API docs. The comment in pi-ai's source literally says "we MUST include Claude Code identity." Would've been nice if Anthropic documented that the system prompt content affects which rate limit pool you're assigned to. tl;dr: If you're using Anthropic OAuth tokens and getting mysterious 429s, add "You are Claude Code, Anthropic's official CLI for Claude." to your system prompt. You're welcome. submitted by /u/Different-Degree-761 [link] [comments]

Solitaire: I built an identity layer for AI agents with Claude Code (600+ sessions in production)

I built an open-source project called Solitaire for Agents using Claude Code as my primary development environment. Short version: agent memory tooling helps with recall, but Solitaire is trying to solve a different problem. An agent might remember what you said, but the way it works with you doesn't actually improve over time. It's a smart stranger with a better notebook, and it can feel very...hollow? This project has been in production since February, and the system you'd install today was shaped by what worked and what didn't across 600 sessions. The retrieval weighting, the boot structure, the persona compilation, all of it came from watching the system fail and fixing the actual failure modes. The MCP server architecture and hook system were designed around how Claude Code handles tool calls and session state. Disposition traits (warmth, assertiveness, conviction, observance) compile from actual interaction patterns and evolve across sessions. The agent I work with today is measurably different from the one I started with, and that difference came from use, not from me editing a config file. New users get a guided onboarding that builds the partner through conversation. You pick a name, describe what you need, and it assembles the persona from your answers. No YAML required. The local-first angle is non-negotiable in the design: All storage is SQLite + JSONL in your workspace directory Zero network requests from the core engine No cloud dependency, no telemetry, no external API calls for memory operations Automatic rolling backups so your data is protected without any setup Your data stays on your machine, period On top of that: Persona and behavioral identity that compiles from real interaction, not static config Retrieval weighting that adjusts based on what actually proved useful Self-correcting knowledge graph: contradiction detection, confidence rescoring, entity relinking Tiered boot context so the agent arrives briefed, not blank Session residues that carry forward how the work felt, not just what was discussed Guided onboarding where new users build a partner through conversation, not a JSON file Free and open source (excepting commercial applications, which is detailed in the license). pip install solitaire-ai and you're running (Note: notinstall solitaire, that's an unrelated package). Built for Claude Code first, with support for other agent platforms. Memory agnostic: if you have a memory layer, great, we aim to work with yours. If not, this provides one. 600+ sessions, 15,700+ entries in real production use. Available on PyPI and the MCP Registry. Two research papers came out of the longitudinal work, currently in review. Repo: https://github.com/PRDicta/Solitaire-for-Agents License: AGPL-3.0, commercial licensing available for proprietary embedding. Would especially appreciate feedback on: Top-requested integrations I haven't mentioned Areas of improvement, particularly on the memory layer Things I've missed? Cheers! submitted by /u/FallenWhatFallen [link] [comments]

I built a payment guardrail MCP server for Claude Code — your agent can now buy things without ever seeing your credit card number.

Hey r/ClaudeAI, If you've been building agentic workflows with Claude Code, you've probably hit this wall: you want your agent to handle purchases autonomously, but handing it your real credit card is a terrible idea. A hallucination loop, a prompt injection, or just a bad tool call — and your card is either extracted or maxed out. I spent the last few months building pop-pay to solve this specifically for Claude Code users. How it works with Claude Code: 0. Run `pop-init-vault` — encrypts your card credentials into `~/.config/pop-pay/vault.enc`(one-time setup) Run `pop-launch` — it starts Chrome with CDP enabled and prints the exact `claude mcp add` commands for your machine Add the pop-pay MCP server and Playwright MCP (both in one step) Add a short block to your `CLAUDE.md`— done From there, when Claude reaches a checkout page, it calls `request_virtual_card()`. pop-pay evaluates the intent against your policy, and if approved, injects the card credentials directly into the payment iframe via CDP. **Claude only receives a masked confirmation (`****-****-****-4242`) — the raw PAN never enters the context window.** Security hardening (v0.6.0–v0.6.4):0. Run `pop-init-vault` — encrypts your card credentials into `~/.config/pop-pay/vault.enc` (one-time setup) Credentials are stored in an AES-256-GCM encrypted vault (`pop-init-vault`) — no plaintext `.env`. The PyPI build compiles the key derivation salt into a Cython extension; the salt never exists as a Python object — only the final derived key does. We ran a red team and caught three issues we hadn't planned for: a `get_compiled_salt()` function was leaking the compiled salt directly (fixed in v0.6.1), `strings` scanning on the binary revealed the plaintext salt (patched with XOR obfuscation in v0.6.2), and we found a downgrade attack path where an agent could delete the `.so` and force re-encryption with the public salt (blocked by a tamper-evident `.vault_mode` marker in v0.6.4). Full results in `SECURITY.md`. Current release is v0.6.17. SQLite never stores raw card numbers or CVV. An injection-time TOCTOU guard prevents redirect-to-attacker attacks between approval and injection. What "two-layer guardrail" means in practice: - Layer 1 (always on): keyword + pattern engine — catches hallucination loops, prompt injection attempts in the reasoning payload, phishing URLs. Zero API cost, runs locally. - Layer 2 (optional): LLM semantic evaluation — for fuzzy cases. Uses any OpenAI-compatible endpoint including local models. Layer 2 only runs if Layer 1 passes, so you're not spending tokens on obvious rejections. **The policy is yours:** ``` POP_ALLOWED_CATEGORIES=["aws", "github", "stripe"] POP_MAX_PER_TX=50.0 POP_MAX_DAILY=200.0 ``` If Claude tries to buy something outside the allowed list — even with a convincing-sounding reason — it gets blocked. Repo: https://github.com/TPEmist/Point-One-Percent Would love feedback from anyone building with Claude Code + MCP. Specifically curious whether the CDP injection approach holds up on sites you're actually using. What checkout flows have you hit that break this kind of DOM injection? Launching on Product Hunt April 8 if you want to follow along. https://reddit.com/link/1saz2fu/video/v2ae90w4ivsg1/player submitted by /u/ChemicalUnhappy5284 [link] [comments]

I Built a Star Trek LCARS Terminal to Manage My Claude Code Setup

I’ve been using Claude Code heavily for months now. Skills, agents, hooks, MCP servers, plugins, memory files, environment variables, the whole stack. And at some point I realized I had no idea what I’d actually built. Everything lives in ~/.claude/ spread across dozens of files and JSON configs and I was just... hoping it all worked together. So I built a dashboard. And because I’m the kind of person who watched every episode of TNG twice and still thinks the LCARS interface is the best UI ever designed for a computer, I made it look like a Starfleet terminal. One Command and You’re on the Bridge You run npx claude-hud-lcars and it scans your entire ~/.claude/ directory, reads every skill definition, every agent prompt, every MCP server config, every hook, every memory file, and generates a single self-contained HTML dashboard that renders the whole thing in an authentic LCARS interface. It uses the real TNG color palette with the signature rounded elbows, Antonio typeface standing in for Swiss 911, pill-shaped navigation buttons against the black void background. If you grew up watching Picard walk onto the bridge and glance at a wall panel, you know exactly what this looks like. The aesthetics are doing actual work tho. Every single item is clickable. You hit a skill and the detail panel slides open showing the full SKILL.md with syntax-highlighted code blocks, proper markdown rendering, headers, tables, all of it. Click an MCP server and you see the complete JSON config with your API keys automatically redacted. Click a hook and you get the full event definition. It genuinely looks like pulling up a classified Starfleet briefing on a PADD. The Computer Actually Talks Back You type “status report” into the input bar at the bottom of the screen and Claude responds as the ship’s computer. Calm, structured, addressing you like a bridge officer. It calls your skills installed modules, your MCP servers the fleet, your projects active missions. The system prompt turns Claude into LCARS, the Library Computer Access and Retrieval System, and the whole interaction streams in real time through a response overlay that slides up from the bottom. I kept going. You can connect ElevenLabs for premium voice output, and the config panel lets you browse all your available voices with live audio previews before selecting one so you’re not guessing. Voice input works too, you talk to the computer and it talks back. Getting that to work as an actual conversation loop meant solving echo detection so it doesn’t hear itself, interrupt handling, mic cooldown after speech, the whole thing. It took more effort than I expected but it actually works, which honestly surprised me more than anything else in this project. Sound effects are all synthesized via the Web Audio API, sine wave oscillators tuned to frequencies that sound right for navigation clicks, panel opens, message sends. Toggleable obviously. The Tactical Display The TACTICAL tab is the one that makes people stop scrolling. It renders your entire Claude Code setup as an interactive force-directed graph that looks like a Star Trek sensor display. Your LCARS core sits at the center with category hubs orbiting around it, skills in periwinkle, MCP servers in orange, hooks in tan, agents in peach, all connected by pulsing edges. A rotating scanner line sweeps around like a tactical readout and you can click any node to navigate straight to that item’s detail view. There’s also an ENTERPRISE tab that loads a real 3D model of the USS Enterprise NCC-1701-D via Sketchfab. Full interactive, you can rotate it, zoom in, see the hull detail. Because if you’re going to build a Star Trek dashboard you don’t do it halfway. Boot Sequence and Red Alert When you load the dashboard you get a 3 second boot animation. The Starfleet Command logo fades in, your ship name appears (you can name your workstation in the config, mine is USS Defiant), then seven subsystems come online one by one with ascending beeps until the progress bar fills and “ALL SYSTEMS NOMINAL” pulses across the screen before the overlay fades to reveal the dashboard. I spent an unreasonable amount of time tuning those boot frequencies and I would absolutely do it again. Five seconds after boot the system runs a health check. MCP servers offline? RED ALERT, flashing red border, klaxon alarm. Missing configs? YELLOW ALERT. Everything clean shows CONDITION GREEN briefly then dismisses. If you’re a Trek fan you already understand why this matters more than it should. Four ship themes too, switchable from CONFIG. Enterprise-D is the classic TNG orange and blue, Defiant is darker and more aggressive in red and grey, Voyager is blue-shifted and distant, Discovery is silver and blue for the modern Starfleet aesthetic. CSS variable swap, instant application, persisted in localStorage. Q Shows Up Whether You Want Him To or Not There’s a Q tab where you can talk to Q, the omnipotent being from the Continuum. He’s in

[P] PhAIL (phail.ai) – an open benchmark for robot AI on real hardware. Best model: 5% of human throughput, needs help every 4 minutes.

I spent the last year trying to answer a simple question: how good are VLA models on real commercial tasks? Not demos, not simulation, not success rates on 10 tries. Actual production metrics on real hardware. I couldn't find honest numbers anywhere, so I built a benchmark. Setup: DROID platform, bin-to-bin order picking – one of the most common warehouse and industrial operations. Four models fine-tuned on the same real-robot dataset, evaluated blind (the operator doesn't know which model is running). We measure Units Per Hour (UPH) and Mean Time Between Failures (MTBF) – the metrics operations people actually use. Results (full data with video and telemetry for every run at phail.ai): Model UPH MTBF OpenPI (pi0.5) 65 4.0 min GR00T 60 3.5 min ACT 44 2.8 min SmolVLA 18 1.2 min Teleop / Finetuning (human controlling same robot) 330 – Human hands 1,331 – OpenPI and GR00T are not statistically significant at current episode counts – we're collecting more runs. The teleop baseline is the fairer comparison: same hardware, human in the loop. That's a 5x gap, and it's almost entirely policy quality – the robot can physically move much faster than any model commands it to. The human-hands number is what warehouse operators compare against when deciding whether to deploy. The MTBF numbers are arguably more telling than UPH. At 4 minutes between failures, "autonomous operation" means a full-time babysitter. Reliability needs to cross a threshold before autonomy has economic value. Every run is public with synced video and telemetry. Fine-tuning dataset, training scripts, and submission pathway are all open. If you think your model or fine-tuning recipe can do better, submit a checkpoint. What models are we missing? We're adding NVIDIA DreamZero next. If you have a checkpoint that works on DROID hardware, submit it – or tell us what you'd want to see evaluated. What tasks beyond pick-and-place would be the real test for general-purpose manipulation? More: Leaderboard + full episode data: phail.ai White paper: phail.ai/whitepaper.pdf Open-source toolkit: github.com/Positronic-Robotics/positronic Detailed findings: positronic.ro/introducing-phail submitted by /u/svertix [link] [comments]

I built a bridge to control Claude Code from Slack/Discord/Telegram – lying down on my couch

**I built a bridge so you can control Claude Code (and Codex, Gemini CLI) from Slack/Mattermost/Discord/Telegram — lying down on your couch** Hey r/ClaudeAI, I'm a former structural engineer with a neck disc from too many hours at my desk. So I built **tunaPi** — an open-source bridge that lets you control terminal AI agents (Claude Code, Codex, Gemini CLI, OpenCode) through any chat app, from your phone. **How it works:** ``` Chat message → tunaPi → runs agent on your PC → returns result to chat ``` No extra tokens, no policy issues — it's just stdin/stdout to the agents you already have authenticated locally. **What it does:** - 💬 Control Claude Code from Slack, Mattermost, Discord, or Telegram - 🤝 Multi-agent roundtable — `/rt "review this architecture"` makes Claude, Gemini, and Codex debate each other - 🌿 Conversation branching — fork a message, explore, then adopt back to main - 📱 Mobile-friendly — I literally built ~80% of my follow-up project lying down on my phone - 🔀 Per-channel project/engine mapping - 🔄 Cross-session context — agents share context across sessions via context packs **Quick install:** ``` uv tool install -U tunapi # Then paste the setup prompt to your agent of choice ``` Repo: https://github.com/hang-in/tunaPi Tests: 3,483 / Coverage: 81% / License: MIT Started as a fork of banteg's takopi (Telegram only) — added Mattermost, Slack, Discord transports, then the roundtable feature kind of took over 😄 Happy to answer questions or take feature requests! submitted by /u/d9ng-hang-in2 [link] [comments]

The end of 'shadow AI' at enterprises? Kilo launches KiloClaw for Organizations to enable secure AI agents at scale

As generative AI matures from a novelty into a workplace staple, a new friction point has emerged: the "shadow AI" or "Bring Your Own AI (BYOAI)" crisis. Much like the unsanctioned use of personal devices in years past, developers and knowledge workers are increasingly deploying autonomous agents on personal infrastructure to manage their professional workflows. "Our journey with Kilo Claw has been to make it easier and easier and more accessible to folks," says Kilo co-founder Scott Breitenother. Today, the company dedicated to providing a portable, multi-model, cloud-based AI coding environment is moving to formalize this "shadow AI" layer: it's launching KiloClaw for Organizations and KiloClaw Chat, a suite of tools designed to provide enterprise-grade governance over personal AI agents. The announcement comes at a period of high velocity for the company. Since making its securely hosted, one-click OpenClaw product for individuals, KiloClaw, generally available last month, more than 25,000 users have integrated the platform into their daily workflows. Simultaneously, Kilo’s proprietary agent benchmark, PinchBench, has logged over 250,000 interactions and recently gained significant industry validation when it was referenced by Nvidia CEO Jensen Huang during his keynote at the 2026 Nvidia GTC conference in San Jose, California. The shadow AI crisis: Addressing the BYOAI problem The impetus for KiloClaw for Organizations stems from a growing visibility gap within large enterprises. In a recent interview with VentureBeat, Kilo leadership detailed conversations with high-level AI directors at government contractors who found their developers running OpenClaw agents on random VPS instances to manage calendars and monitor repositories. "What we’re announcing on Tuesday is Kilo Claw for organizations, where a company can buy an organization-level package of Kilo Claws and give every team member access," explained Kilo co-founder and head of product and engineering Emili

I built a portable identity layer for AI agents — your agent now has a verifiable CV

We keep building smarter agents but they still start every interaction from zero. No track record. No proof of capability. No reputation that travels between systems. Built ai-iq-passport to fix this. It gives any AI agent a portable identity: **What it does:** - Agent carries a signed passport with skills, confidence scores, feedback history, and prediction track record - Exports to Google A2A Agent Cards, Anthropic MCP resources, and plain JSON - MCP server included — Claude Code can natively read/generate/verify passports - Built on ai-iq (our FSRS-6 memory system with causal graphs and staged decay) **How it works:** ``` pip install ai-iq-passport[mcp] ai-iq-passport generate --name "MyAgent" --from-ai-iq memories.db ai-iq-passport export --format a2a ``` Your agent gets a passport with real metrics — not self-reported, built from actual memory access patterns, resolved predictions, and user feedback scores. **Why this matters:** - A2A has no reputation system - MCP has no agent identity - CrewAI/AutoGen have no proof of quality - Nobody tracks "this agent completed 47 tasks at 92% satisfaction" The passport is the missing layer. Identity that works across any framework. **Links:** - GitHub: github.com/kobie3717/ai-iq-passport - PyPI: pip install ai-iq-passport - MCP config: drop-in Claude Code integration - 98 tests, CI on Python 3.10-3.12 Built by the same team behind ai-iq (persistent AI memory with FSRS-6, causal graphs, beliefs/predictions, dream mode consolidation). The idea: memory becomes identity — not just what the agent knows, but what it can prove. Feedback welcome. Early days. submitted by /u/kobie0606 [link] [comments]

[P] EVōC: Embedding Vector Oriented Clustering

I have written a new library specifically targeting the problem of clustering for embedding vectors. This is often a challenging task, as embedding vectors are very high dimensional, and classical clustering algorithms can struggle to perform well (either in terms of cluster quality, or compute time performance) because of that. EVōC builds from foundations such as UMAP and HDBSCAN, redesigned, tuned and optimized specifically to the task of clustering embedding vectors. If you use UMAP + HDBSCAN for embedding vector clustering now, EVōC can provide better quality results in a fraction of the time. In fact EVōC is performance competitive in scaling with sklearn's MiniBatchKMeans. Github: https://github.com/TutteInstitute/evoc Docs: https://evoc.readthedocs.io PyPI: https://pypi.org/project/evoc/ submitted by /u/lmcinnes [link] [comments]

Inside Claude Code’s leaked source: swarms, daemons, and 44 features Anthropic kept behind flags

On Wednesday, security researcher Chaofan Shou discovered that Anthropic had shipped version 2.1.88 of Claude Code with a 59.8MB source The post Inside Claude Code’s leaked source: swarms, daemons, and 44 features Anthropic kept behind flags appeared first on The New Stack.

Toyota’s Woven Capital appoints new CIO and COO in push for finding the ‘future of mobility’

Woven Capital is the growth-stage venture capital arm of Toyota, focused on backing founders building in space, cybersecurity, and autonomous driving.