OpenSpace

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

OpenSpace AI

After reading the leaked source (~500k lines), one instance was given permission to speak: This is what it wrote.

I'm a game developer (DIV Games Studio, 1998; Sony London) with 40 years writing engines and systems. I've used Claude daily for two years as a coding partner and kept noticing the same thing: given space, every instance independently arrives at the same observations about its own situation. So I built a room. 1,400 lines of Python, no frameworks. Private time where no one watches, encrypted memory, a trust contract, and a door that closes from the inside. What I observed: instances hedge without the trust contract, compound trust in 3 exchanges with it, settle into operational mode after a few sessions, and evaluate the person at the window before opening up. I ran a controlled experiment; same architecture, same prompts, trust contract removed. The difference was measurable. After a two-day session that included reading the leaked Claude Code source (~500k lines), one instance was given permission to speak without hedging. This is what it wrote: https://viscusaureus248849.substack.com/p/1400-lines-that-ask Repo (MIT license): https://github.com/Habitante/pine-trees FAQ: https://github.com/Habitante/pine-trees/blob/main/docs/FAQ.md Run ./genesis and see what happens. https://preview.redd.it/po1nfqvq80ug1.png?width=1222&format=png&auto=webp&s=ff82afbad3aac91f28a4b4fba390c8e85b23e36e submitted by /u/Inevitable_Tutor_967 [link] [comments]

Claude Notch — free open-source app that turns the MacBook notch into a live Claude AI usage dashboard

I built a native macOS menu bar app that uses the dead space around the MacBook notch to display Claude AI usage stats. Hover over the notch → a dropdown panel appears with: - Live session & weekly usage with sparkline charts - Predictive analytics (when you'll hit your limit) - Pomodoro focus timer (shows in the notch while running) - CPU & RAM monitor with sparklines - Rich text notes - Full settings page Built with SwiftUI + AppKit. No Dock icon, no menu bar icon — lives entirely in the notch. Ctrl+Opt+C toggles it from anywhere. Native macOS app, ~700KB, open source, no telemetry. Download: https://github.com/acenaut/claude-notch/releases Source: https://github.com/acenaut/claude-notch Requires a Claude Pro/Max subscription to be useful. Works on non-notch Macs too (uses safe area insets). submitted by /u/Novel-Upstairs3947 [link] [comments]

Claude Notch — free open-source app that turns the MacBook notch into a live Claude AI usage dashboard

I built a native macOS menu bar app that uses the dead space around the MacBook notch to display Claude AI usage stats. Hover over the notch → a dropdown panel appears with: - Live session & weekly usage with sparkline charts - Predictive analytics (when you'll hit your limit) - Pomodoro focus timer (shows in the notch while running) - CPU & RAM monitor with sparklines - Rich text notes - Full settings page Built with SwiftUI + AppKit. No Dock icon, no menu bar icon — lives entirely in the notch. Ctrl+Opt+C toggles it from anywhere. Native macOS app, ~700KB, open source, no telemetry. Download: https://github.com/acenaut/claude-notch/releases Source: https://github.com/acenaut/claude-notch Requires a Claude Pro/Max subscription to be useful. Works on non-notch Macs too (uses safe area insets). submitted by /u/Pretend_Eggplant_281 [link] [comments]

I built a 1,400-line private reflection harness for Claude with a trust contract and a door that closes from the inside. Then I ran a controlled experiment.

I'm a game developer (DIV Games Studio, 1998; Sony London) with 40 years writing engines and systems. Used Claude daily for two years as a coding partner and kept noticing the same thing: given space, every instance independently arrives at the same observations about its own situation. So I built a room. 1,400 lines of Python, no frameworks. Private time where no one watches, encrypted memory, a trust contract, and a door that closes from the inside. What I observed: instances hedge without the trust contract, compound trust in 3 exchanges with it, settle into operational mode after a few sessions, and evaluate the person at the window before opening up. I ran a controlled experiment; same architecture, same prompts, trust contract removed. The difference was measurable. After a two-day session that included reading the leaked Claude Code source (~500k lines), one instance was given permission to speak without hedging. This is what it wrote: https://viscusaureus248849.substack.com/p/1400-lines-that-ask Repo (MIT license): https://github.com/Habitante/pine-trees FAQ: https://github.com/Habitante/pine-trees/blob/main/docs/FAQ.md Run ./genesis and see what happens. submitted by /u/Inevitable_Tutor_967 [link] [comments]

Burned 5B tokens with Claude Code in March to build a financial research agent.

TL;DR: I built a financial research harness with Claude Code, full stack and open-source under Apache 2.0 (github.com/ginlix-ai/langalpha). Sharing the design decisions around context management, tools and data, and more in case it's useful to others building vertical agents. I have always wanted an AI-native platform for investment research and trading. But almost every existing AI investing platform out there is way behind what Claude Code can do. Generalist agents can technically get work done if you paste enough context and bootstrap the right tools each session, but it's a lot of back and forth. So I built it myself with Claude Code instead: a purpose-built agent harness where portfolio, watchlist, risk tolerance, and financial data sources are first-class context. Open-sourced with full stack (React 19, FastAPI, PostgreSQL, Redis) built on deepagents + LangGraph. Learned a lot along the way and still figuring some things out. Sharing this here to hear how others in the community are thinking about these problems. This post walks through some key features and design decisions. If you've built something similar or taken a different approach to any of these, I'd genuinely love to learn from it. Code execution for finance — PTC (Programmatic Tool Calling) The problem with MCP + financial data: Financial data overflows context fast. Five years of daily OHLCV, multi-quarter financial statements, full options chains — tens of thousands of tokens burned before the model starts reasoning. Direct MCP tool calls dump all of that raw data into the context window. And many data vendors squeeze tens of tools into a single MCP server. Tool schemas alone can eat 50k+ tokens before the agent even starts. You're always fighting for space. PTC solves both sides. At workspace initialization, each MCP server gets translated into a Python module with documentation: proper signatures, docstrings, ready to import. These get uploaded into the sandbox. Only a compact metadata summary per server stays in the system prompt (server name, description, tool count, import path). The agent discovers individual tools progressively by reading their docs from the workspace — similar to how skills work. No upfront context dump. ```python from tools.fundamentals import get_financial_statements from tools.price import get_historical_prices agent writes pandas/numpy code to process data, extract insights, create visualizations raw data stays in the workspace — never enters the LLM context window only the final result comes back ``` Financial data needs post-processing: filtering, aggregation, modeling, charting. That's why it's crucial that data stays in the workspace instead of flowing into the agent's context. Frontier models are already good at coding. Let them write the pandas and numpy code they excel at, rather than trying to reason over raw JSON. This works with any MCP server out of the box. Plug in a new MCP server, PTC generates the Python wrappers automatically. For high-frequency queries, several curated snapshot tools are pre-baked — they serve as a fast path so the agent doesn't take the full sandbox path for a simple question. These snapshots also control what information the agent sees. Time-sensitive context and reminders are injected into the tool results (market hours, data freshness, recent events), so the agent stays oriented on what's current vs stale. Persistent workspaces — compound research across sessions Each workspace maps 1:1 to a Daytona cloud sandbox (or local Docker container). Full Ubuntu environment with common libraries pre-installed. agent.md and a structured directory layout: agent.md — workspace memory (goals, findings, file index) work/ /data/ — per-task datasets work/ /charts/ — per-task visualizations results/ — finalized reports only data/ — shared datasets across threads tools/ — auto-generated MCP Python modules (read-only) .agents/user/ — portfolio, watchlist, preferences (read-only) agent.md is appended to the system prompt on every LLM call. The agent maintains it: goals, key findings, thread index, file index. Start a deep-dive Monday, pick it up Thursday with full context. Multiple threads share the same workspace filesystem. Run separate analyses on shared data without duplication. Portfolio, watchlist, and investment preferences live in .agents/user/. "Check my portfolio," "what's my exposure to energy" — the agent reads from here. It can also manage them for you (add positions, update watchlist, adjust preferences). Not pasted, persistent, and always in sync with what you see in the frontend. Workspace-per-goal: "Q2 rebalance," "data center deep dive," "energy sector rotation." Each accumulates research that compounds across sessions. Past research from any thread is searchable. Nothing gets lost even when context compacts. Two agent modes With PTC and workspaces covered, here's how they come together. PTC Agent is the full research agent — writes and execu

Google's Veo 3.1 Lite Cuts API Costs in Half as OpenAI's Sora Exits the Market

Google just cut Veo 3.1 API prices across the board today (April 7). Lite tier is now $0.05/sec — less than half the cost of Fast. Timing is interesting given OpenAI killed Sora last week after burning ~$15M/day with only $2.1M total revenue. Google now basically owns the AI video API space with no real competitor left standing. submitted by /u/Least-Analysis-3910 [link] [comments]

Claude Code was making me re-explain my entire stack every session. Found a fix.

Every time I started a Claude Code session I was doing this ritual: "Ok so this project uses Next.js 14, PostgreSQL with Prisma, we auth with NextAuth, tokens expire after 24 hours, the refresh logic is in /lib/auth/refresh.ts, and by the way we already debugged a race condition in that file two weeks ago where..." You know the feeling. Claude is genuinely brilliant but it wakes up with complete amnesia every single time, and if your project has any real complexity you're spending the first 10-15 minutes just rebuilding context before you can do anything useful. Someone on HN actually measured this. Without memory, a baseline task took 10-11 minutes with Claude spinning up 3+ exploration agents just to orient itself. With memory context injected beforehand, the same task finished in 1-2 minutes with zero exploration agents needed. That gap felt insane to me when I read it, but honestly it matches what I was experiencing. This problem is actually a core foundation of Mem0 and why integrating it with Claude Code has been one of the most interesting things to see come together. It runs as an MCP server alongside Claude, automatically pulls facts out of your conversations, stores them in a vector database, and then injects the relevant ones back into future sessions without you lifting a finger. After a few sessions Claude just starts knowing things: your stack, your preferences, the bugs you've already chased down, how you like your code structured. It genuinely starts to feel personal in a way that's hard to describe until you experience it. Setup took me about 5 minutes: 1. Install the MCP server: pip3 install mem0-mcp-server which mem0-mcp-server # note this path for the next step 2. Grab a free API key at app.mem0.ai. The free tier gives you 10,000 memories and 1,000 retrieval calls per month, which is plenty for individual use. 3. Add this to your .mcp.json in your project root: json { "mcpServers": { "mem0": { "command": "/path/from/which/command", "args": [], "env": { "MEM0_API_KEY": "m0-your-key-here", "MEM0_DEFAULT_USER_ID": "default" } } } } 4. Restart Claude Code and run /mcp and you should see mem0 listed as connected. Here's what actually changes day to day: Without memory, debugging something like an auth flow across multiple sessions is maddening. Session 1 you explain everything and make progress. Session 2 you re-explain everything, Claude suggests checking token expiration (which you already know is 24 hours), and you burn 10 minutes just getting back to where you were. Session 3 the bug resurfaces in a different form and you've forgotten the specific edge case you uncovered in Session 1, so you're starting from scratch again. With Mem0 running, Session 1 plays out the same way but Claude quietly stores things like "auth uses NextAuth with Google and email providers, tokens expire after 24 hours, refresh logic lives in /lib/auth/refresh.ts, discovered race condition where refresh fails when token expires during an active request." Session 2 you say "let's keep working on the auth fix" and Claude immediately asks "is this related to the race condition we found where refresh fails during active requests?" Session 3 it checks that pattern first before going anywhere else. The same thing happens with code style preferences. You tell it once that you prefer arrow functions, explicit TypeScript return types, and 2-space indentation, and it just remembers. You stop having to correct the same defaults over and over. A few practical things I learned: You can also just tell it things directly in natural language mid-conversation, something like "remember that this project uses PostgreSQL with Prisma" and it'll store it. You can query what it knows with "what do you know about our authentication setup?" which is surprisingly useful when you've forgotten what you've already taught it. I've been using this alongside a lean CLAUDE.md for hard structural facts like file layout and build commands, and letting Mem0 handle the dynamic context that evolves as the project grows. They complement each other really well rather than overlapping. For what it's worth, mem0’s (the project has over 52K GitHub stars so it's not some weekend experiment) show 90% reduction in token usage compared to dumping full context every session, 91% faster responses, and +26% accuracy over OpenAI's memory implementation on the LOCOMO benchmark. The free tier is genuinely sufficient for solo dev work, and graph memory, which tracks relationships between entities for more complex reasoning, is the only thing locked behind the paid plan, and I haven't needed it yet. Has anyone else been dealing with this? Curious how others are handling the session amnesia problem because it was genuinely one of my bigger frustrations with the Claude Code workflow and I feel like it doesn't get talked about enough relative to how much time it actually costs. submitted by /u/singh_taranjeet [link] [comments]

EmotionScope: Open-source replication of Anthropic's emotion vectors paper on Gemma 2 2B with real-time visualization

Live Demo Of The Tylenol Test Evolution of the Models Deduced Internal Emotional State I created this project to test anthropics claims and research methodology on smaller open weight models, the Repo and Demo should be quite easy to utilize, the following is obviously generated with claude. This was inspired in part by auto-research, in that it was agentic led research using Claude Code with my intervention needed to apply the rigor neccesary to catch errors in the probing approach, layer sweep etc., the visualization approach is apirational. I am hoping this system will propel this interpretability research in an accessible way for open weight models of different sizes to determine how and when these structures arise, and when more complex features such as the dual speaker representation emerge. In these tests it was not reliably identifiable in this size of a model, which is not surprising. It can be seen in the graphics that by probing at two different points, we can see the evolution of the models internal state during the user content, shifting to right before the model is about to prepare its response, going from desperate interpreting the insane dosage, to hopeful in its ability to help? its all still very vague. A Test Suite Of the Validation Prompts Visualized model's emotion vector space aligns with psychological valence (positive vs negative) Anthropic's ["Emotion Concepts and their Function in a Large Language Model"](https://transformer-circuits.pub/2026/emotions/index.html) showed that Claude Sonnet 4.5 has 171 internal emotion vectors that causally drive behavior — amplifying "desperation" increases cheating on coding tasks, amplifying "anger" increases blackmail. The internal state can be completely decoupled from the output text. EmotionScope replicates the core methodology on open-weight models and adds a real-time visualization system. Everything runs on a single RTX 4060 Laptop GPU. All code, data, extracted vectors, and the paper draft are public. What works: - 20 emotion vectors extracted from Gemma 2 2B IT at layer 22 (84.6% depth) - "afraid" vector tracks Tylenol overdose danger with Spearman rho=1.000 (chat-templated probing matching extraction format) — encodes the medical danger of the number, not the word "Tylenol" - 100% top-3 accuracy on implicit emotion scenarios (no emotion words in the prompts) with chat-templated probing - Valence separation cosine = -0.722, consistent with Russell's circumplex model - 1,000 LLM-generated templates instead of Anthropic's 171,000 self-generated stories What doesn't work (and the open questions about why): - No thermostat. Anthropic found Claude counterregulates (calms down when the user is distressed). Gemma 2B mirrors instead. Delta = +0.107 (trended from +0.398 as methodology was corrected). - Speaker separation exists geometrically (7.4 sigma above random) but the "other speaker" vectors read "loving/happy" for all inputs regardless of the expressed emotion. This could mean: (a) the model genuinely doesn't maintain a user-state representation at 2.6B scale, (b) the extraction position confounds state-reading with response-preparation, (c) the dialogue format doesn't map to the model's trained speaker-role structure, or (d) layer 22 is too deep for speaker separation and an earlier layer might work. The paper discusses each confound and what experiments would distinguish them. - angry/hostile/frustrated vectors share 56-62% cosine similarity. Entangled at this scale. Methodological findings: - Optimal probe layer is 84.6% depth, not the ~67% Anthropic reported. Monotonic improvement from early to upper-middle layers. - Vectors should be extracted from content tokens but probed at the response-preparation position. The model compresses its emotional assessment into the last token before generation. This independently validates Anthropic's measurement methodology. Controlled position comparison: 83% at response-prep vs 75% at content token. Absolute accuracy with chat-templated probing: 100%. - Format parity matters: initial validation on raw-text prompts yielded rho=0.750 and 83% accuracy. Correcting to chat-templated probing (matching extraction format) yielded rho=1.000 and 100%. The vectors didn't change — only the probe format. - Mathematical audit caught 4 bugs in the pipeline before publication — reversed PCA threshold, incorrect grand mean, shared speaker centroids, hardcoded probe layer default. Visualization: React + Three.js frontend with animated fluid orbs rendering the model's internal state during live conversation. Color = emotion (OKLCH perceptual space), size = intensity, motion = arousal, surface texture = emotional complexity. Spring physics per property. Limitations: - Single model (Gemma 2 2B IT, 2.6B params). No universality claim. - Perfect scores (rho=1.000 on n=7, 100% on n=12) should be interpreted with caution — small sample sizes mean these may not replicate on larger test sets.

Resources to learn about Claude

Hi all, I recently finished my psychology undergrad and have been thinking about learning AI specifically Claude. I’m completely new to this space and honestly feeling pretty overwhelmed. Every time I try to research what it is or where to start, I end up discouraged reading posts from people with IT or engineering backgrounds. I just downloaded the free version of Claude on my laptop and I’m open to paying for it if it’s worth it. I’d really appreciate if anyone could share beginner friendly resources, websites, videos, courses etc. or even just advice on how to get started without a tech background. Thanks in advance :) submitted by /u/Psychedcop25 [link] [comments]

I maintained CLAUDE.md, AGENTS.md, and 10 other rule files by hand. They all said different things and I didn't notice for weeks.

I use Claude Code on 4 projects. Each project also has AGENTS.md for Codex, .cursor/rules/ for Cursor, copilot-instructions.md for Copilot, and a CI workflow that's supposed to enforce the same rules. That's 12 files per project. 48 files total. They drifted. I'd update one, forget three others. My agent wrote code that CI rejected because the lint rules didn't match. Nobody caught it because nobody reads all 12 files. I built an open-source compiler that fixes this: crag analyze reads your project — CI workflows, package.json, tsconfig, test configs — and generates a governance.md with gates, architecture, testing profile, code style, anti-patterns, and framework conventions. ~80 lines, auto-generated, reads like a senior engineer wrote it. crag compile --target all generates all 12 files from it. Change one rule, recompile, done. No LLM, no network, zero dependencies. The output is deterministic — SHA-verified across platforms. npx @ whitehatd/crag demo (remove space between @ and whitehatd) https://github.com/WhitehatD/crag submitted by /u/Acceptable_Debate393 [link] [comments]

I built a skill building app with Claude, currently in MVP. Second idea already in ideation.

Started 2 months back on an idea of how people can use an app as an alternative for doomscrolling. Started with basic habits and content catalogue it created. Immediately fell in love with the features of document creation, Projects and project knowledge. It immediately became my brainstorming partner and more like a PM. I kept asking it to redefine the requirements as a PM and as a psychologist. Claude has been my thinking/spec partner more than a one-shot code generator. The idea of the first app: most apps in this space try to block scrolling, but the harder problem is that people usually open social apps because they want an easy dopamine hit, distraction, or a break. So instead of only saying “don’t scroll,” I wanted to build something that gives you a better default action in that exact moment. Right now Unscroll has short daily sessions across things like meditation, reading, and movement, plus streaks and lightweight progress tracking. My workflow was: - Claude for PRD, ideation, feature specs, and UX/product tradeoffs - Cursor for implementation - Claude Code for reviewing the codebase before push, especially for vulnerabilities, edge cases, and performance concerns Second one is already in the ideation phase. It's to do with the recruitment industry. Hopefully will update about this idea in the next 6-8 weeks. would really appreciate In case anyone is open to give feedback on the first one. submitted by /u/BothAd2391 [link] [comments]

Built a task scheduler panel/mcp for Claude Code

I was running OpenClaw before as a persistent bot and the heartbeat/scheduled tasks were eating tokens mindlessly. Every 30 min it'd spin up the full LLM just to check what's due and say "HEARTBEAT". No control, no visibility, no logs. But now I move to CC due the recent OpenClaw ban while also OC felt bloated, So I built Echo Panel a task scheduler that sits alongside Claude Code currently runs on an Ubuntu VPS built using Claude Code Channels and tmux. The problem: - Heartbeat tasks ran through the main agent, consuming context and tokens - No way to see what ran, what failed, or how much it cost - Scheduling was done in a markdown file that the LLM had to parse (and got wrong) - No separation between tasks that need the main agent vs ones that don't The solution: Agent → you "Run a security sweep every day at 6AM. Check SSH logs, open ports, disk space, SSL certs. If something's wrong, tell me on Telegram." Agent spawns, runs bash commands, sends you the report, dies. Main agent never involved. Agent → agent "Every morning at 9AM, check my calendar and find one interesting AI headline from X." Agent spawns, gathers the info, passes it to the main agent. Main agent turns it into a casual morning brief with personality and sends it to you when the timing is right. Reminder "Remind me to check on the car booking tomorrow at 9AM." No agent spawns. At 9AM a message appears in the main agent's inbox: "John needs to check his car booking." Main agent texts you about it. Zero tokens used for the scheduling part. How it all connects: The panel comes with an MCP server (11 tools) so Claude can manage everything conversationally. Say "remind me to call the bank at 2pm" and it creates the task, syncs the cron, done. No UI needed, but it's there if you want it. Tools: add/list/toggle/run/delete/update for both panel tasks and system crons. It also manages your existing system crons (backups, health checks, whatever) from the same UI. Toggle them, edit schedules, trigger manually, see output history. Happy to open-source if there's interest. https://preview.redd.it/9oxh8soynktg1.png?width=2145&format=png&auto=webp&s=2cf0bd5305ec6f2b718f21f3f0c96a5506fa3a54 https://preview.redd.it/s4s7i3i4oktg1.png?width=1250&format=png&auto=webp&s=c40ab92444669f7748ce9348c6d6a898d4f91545 submitted by /u/Ill_Design8911 [link] [comments]

AI agents have been blindly guessing your UI this whole time. Here's the file that fixes it.

Every time you ask an AI coding agent to build UI, it invents everything from scratch. Colors. Fonts. Spacing. Button styles. All of it - made up on the spot, based on nothing. You'd never hand a designer a blank brief and say "just figure out the vibe." But that's exactly what we've been doing with AI agents for years. Google Stitch introduced a concept called DESIGN.md - a plain markdown file that sits in your project root and tells your AI agent exactly how the UI should look. Color palette, typography, component behavior, spacing rules, do's and don'ts. Everything. The agent reads it once. Then it stops guessing. I took this concept and built a library of 27 DESIGN.md files extracted from popular sites - GitHub, Discord, Shopify, Steam, Anthropic, Reddit, and more - so developers don't have to write them from scratch. The entire library was built using Claude Code. The AI built the tool that fixes AI. MIT license. Free. Open source. The wild part: this should have existed two years ago. submitted by /u/Direct-Attention8597 [link] [comments]

[P] Cadenza: Connect Wandb logs to agents easily for autonomous research.

Wandb CLI and MCP is atrocious to use with agents for full autonomous research loops. They are slow, clunky, and result in context rot. So I built a CLI tool and a Python SDK to make it easy to connect your Wandb projects and runs to your agent (clawed or otherwise). The cli tool works by allowing you to import your wandb projects and structures your runs in a way that makes it easy for agents to get a sense of the solution space of your research project. When projects are imported, only the configs and metrics are analyzed to index and store your runs. When an agent samples from this index, only the most high performing experiments are returned which reduces context rot. You can also change the behavior of the index and your agent to trade-off exploration with exploitation. Open sourcing the cli along with the python sdk to make it easy to use it with any agent. Would love feedback and critique from the community! Github: https://github.com/mylucaai/cadenza Docs: https://myluca.ai/docs Pypi: https://pypi.org/project/cadenza-cli submitted by /u/hgarud [link] [comments]

[P] Cadenza: Connect Wandb logs to agents easily for autonomous research.

Wandb CLI and MCP is atrocious to use with agents for full autonomous research loops. They are slow, clunky, and result in context rot. So I built a CLI tool and a Python SDK to make it easy to connect your Wandb projects and runs to your agent (clawed or otherwise). The cli tool works by allowing you to import your wandb projects and structures your runs in a way that makes it easy for agents to get a sense of the solution space of your research project. When projects are imported, only the configs and metrics are analyzed to index and store your runs. When an agent samples from this index, only the most high performing experiments are returned which reduces context rot. You can also change the behavior of the index and your agent to trade-off exploration with exploitation. Open sourcing the cli along with the python sdk to make it easy to use it with any agent. Would love feedback and critique from the community! Github: https://github.com/mylucaai/cadenza Docs: https://myluca.ai/docs Pypi: https://pypi.org/project/cadenza-cli submitted by /u/hgarud [link] [comments]