Atomic Agents

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Atomic Agents AI

Connected a Robinhood Account to Claude Code and Codex for Autonomys Agentic Trading... Update 1

Update to my original post: https://www.reddit.com/r/ClaudeAI/comments/1u8nagi/connected_a_robinhood_account_to_claude_code_and/ I'm building a fully autonomous daily stock-trading desk in a Robinhood "Agentic" account. Opus is the CEO/PM, Codex (a different model family) is a red-team that tries to kill every trade, and a local Gemma model is an always-on news scout. I spent the last few days tweaking the process, ensuring guardrails, outlining goals, and fixing bugs/issues. I wanted to share some of the .md files that we created. Then answer some of your questions from the first post. Below are the core .md files, the wiring behind them, and what we tailored this week. 🔹 The Charter (the constitution). One file the agents are bound by every run. It locks the mandate — a 50/50 "barbell," half a survival core of broad ETFs, half asymmetric swings — and the universe: listed equities/ETFs only, no options, no crypto, no margin, so the worst case stays bounded. Then the hard rules: a stop on every swing, a per-position size cap, a daily order cap with a buy/sell split, a circuit breaker that halts new risk on a drawdown, and an emergency stop (no new buys if the market's down hard or volatility spikes). It also fixes execution quality — whole-share trades use marketable limit orders, never naked market orders. Nothing the agents do overrides the charter; changes are logged with a date and a reason. 🔹 The Decision Journal. One entry per trade and per rejection, written the moment the call is made: the thesis, what research said, what the red-team said, the decision and why, and a review date. The rejections matter as much as the fills. Today's entry is a documented process breach — the CEO overrode its own morning decision, the red-team later graded it a mistake, and it's all in there verbatim. Honest beats flattering. 🔹 The Playbook. The checklist the loop reads before generating any idea — trend/momentum/relative strength, volatility, catalysts, sizing — plus a growing list of banked lessons. Each morning's coaching review can promote a durable lesson up into it, so a mistake made once becomes a rule read every day after. 🔹 The Coaching log. A next-morning self-review: read yesterday's journal and the actual prices, grade each call (did the thesis play out, did the stop behave, what's the lesson), promote anything durable into the playbook. That's the loop that closes the day. 🔧 Under the hood (a taste of the wiring). The desk runs as scheduled headless agent sessions (think cron): a weekday-morning trading loop, an afternoon pre-close risk pass, a Sunday strategy review. Each is a Claude session that follows a prompt file, calls tools, and writes the .md files. Models are tiered for cost — Sonnet for routine daily work, Codex as a CLI (codex exec) for heavy adversarial reasoning, Opus for the weekly review and exception escalations. Trading goes through an MCP (Model Context Protocol) server for the broker, so the agent calls typed tools like get_portfolio and place_equity_order instead of scraping a screen. The part that actually made it autonomous (this morning's .json change): there are two independent gates, and both must be open. Broker side — the account is a Robinhood "Agentic" account (agentic_allowed: true), which lets an agent trade it. Harness side — Claude Code itself won't let an agent place a real-money order on a blanket "you're autonomous," and won't let the agent grant itself that permission. We hit this live: the first trade attempt was blocked, and so was the agent's attempt to edit its own settings. The unlock is a one-time human edit to settings.json: "permissions": { "allow": [ "mcp__ __place_equity_order", "mcp__ __cancel_equity_order" ] } That single allow-list is the line between "asks me to approve every trade" and "trades on its own." A human turns that key once, deliberately — which is exactly the right design. An AI that could silently grant itself the power to move real money is the thing you don't want. Then the reliability scaffolding — small scripts the scheduled jobs call: a single-instance lock (an atomic lockfile + stale-timeout) so a duplicate fire or a manual session can't trade over each other; a watchdog (a Windows scheduled task, every 5 min) that restarts the local scout if it dies; an off-laptop dead-man switch (healthchecks.io) — the loop pings it on completion, the scout pings a heartbeat during market hours, so if a run stalls or the machine dies I get alerted on a separate channel; start/finish heartbeats to my phone, so a silent failure is loud, not invisible. That last cluster is the unglamorous 80% of making "autonomous" actually trustworthy — and it's where most of this week went. Answering some questions from the last thread: "Where do you get the market news?" Two layers. The always-on scout pulls headlines from public RSS (MarketWatch, CNBC, Yahoo Finance, etc.), and a local Gemma model triages each against the actu

Unit testing a novel

Full post (with the diagrams and the live, self-spoiler-aware wiki): https://www.worldfall.ink/blog/#unit-tests-for-a-novel When George R. R. Martin needs to know the color of a minor knight's eyes, he emails two superfans who run a wiki, because after five thousand pages they hold the continuity of Westeros better than he does. I find that fact comforting and alarming at the same time. Comforting, because the best worldbuilder alive could not keep it all in his head either. Alarming, because the industry-standard fallback is two patient people in Sweden. I came to this problem from software, where we stopped trusting our heads decades ago. The tool we reached for instead is called the unit test, and it deserves a short introduction for readers who have never shipped code. What a unit test is, and why programmers live by them A large program is a million small promises. This function, given a date, returns the right day of the week; that one, given an empty list, returns zero instead of crashing. The program only works if thousands of these hold at once, and the program never stops changing. It is edited daily, for years, by people who cannot remember every promise the code has ever made, and changes do not stay where you put them: you improve how the program handles dates, and something breaks in a corner of the billing code you have never read, because it quietly depended on the old behavior. In principle you could re-check everything by hand after every edit. In practice no human ever has: there are too many promises, the checking is mind-numbing, the deadline is Friday. We check what we remember to worry about, and things slip through. A unit test is the working answer: a tiny script that checks exactly one promise ("give the date function February 29th; confirm it doesn't lie") and complains loudly when it breaks. One test is almost worthless. Thousands of them, rerun by a machine after every change, without boredom, without skipping the ones it checked yesterday, are how software holds together at all. You still cannot test every case up front; nobody can, and bugs still get through. But the suite is a ratchet: every escaped bug becomes a new test the day you fix it, and the same mistake never comes back unannounced. The code forgets; the tests don't. If you have written a long story, you have lived the unfixed version of this. A novel is edited the same way, daily, for years, by someone who cannot re-read the whole book after every change. How the magic is rationed, who knows which secret by chapter eleven, a character's stated reason versus his real one: each is a promise some later scene silently depends on, and a revision in chapter nineteen can break a promise made in chapter three. So we spot-check what we remember to worry about, and things get through. In fiction the escaped bug is called a continuity error, and readers of serialized fantasy hunt them for sport. So before drafting a word of my own book, I built the thing I would build at work: a small test suite that runs against the story, and a habit of turning every mistake it misses into a check it will never miss again. (A purist will read on and object that what I built is closer to a linter than to a unit test suite. Granted. The habit is the import, not the taxonomy.) The idea in one paragraph Treat the world of the story as data, and the chapters as code that depends on it. The world lives as a graph of entities (characters, places, factions, magic systems), each carrying small, individually addressable facts. Chapters declare, in machine-readable front matter, which facts they dramatize and which declared motive every major character choice serves. A linter walks the whole thing and fails loudly when a reference dangles, a rule gets bent, or a choice serves no motive anyone wrote down. None of this judges the prose. It guards the structure underneath the prose, the way tests guard a system while you refactor it. If that sounds like a story bible with a build step, it mostly is. The interesting question is why story bibles always rot and this one doesn't, and the answer is new; it gets its own section near the end. The rest of this post makes that concrete, and concreteness needs an example. So first, the example, with all the context you need. The example First Keel is a fantasy novel I am writing, the first book of a series called Worldfall. A permanent storm-sea has kept two continents apart for so long they have mostly forgotten each other. Once in roughly eighty years the storm dies for eleven months (an Opening), and the two worlds flood into each other through one chokepoint port city: a compressed Columbian exchange, then the door slams shut for another lifetime. A church, the Temple of the Calm, claims its liturgy keeps the sea passable, and owns the calendar that says when it opens. The magic system runs on linguistic divergence: the sealed centuries split one ancestral language into two drifted branches, and

I built a macOS app with Claude Code to fix the thing Claude Code can't fix on its own: it forgets your repo every session

I'm the solo dev, and I built this with Claude Code, for Claude Code users, so flagging that up front. The itch was simple. Every new Claude Code session starts from zero. My CLAUDE.md kept growing, going stale, and getting truncated, and there was no way to tell when a note no longer matched the actual code. I was re-explaining the same project every morning. So over the last several months I built Memophant, a native macOS app, almost entirely in Claude Code itself. It keeps your project memory as plain markdown inside your git repo and serves it back to Claude Code through a bundled MCP server. Next session, Claude reads the memory at startup and is already up to speed. No copy-paste, no re-priming. What it actually does: Stores memory as plain markdown in your repo across tiers: an atomic knowledge graph, a long-form wiki, a design system, a code-symbol index, a TASKS.md kanban, imported sessions, documents, and a vendor/credential registry (secrets stay in your Keychain). Exposes all of it to Claude Code over MCP (search_memories, search_code, write_memory, and more), so memory lives in your editor instead of a context window you keep rebuilding. Distills Claude Code transcripts into durable notes. You hand it a session, it proposes memory, you approve note by note. Flags drift: every note records the commit it was written against, so when the code moves the note shows as stale instead of quietly misleading the next session. How Claude helped: beyond writing most of the Swift, Claude Code was the test case. I used the drift and distillation features on Memophant's own repo while building it, which is how I tuned what gets surfaced versus what stays out of context. It's free to try: a 30-day trial, no account, no card. After the trial the core (reading, editing, search, drift, commits, the MCP server for your existing memory) stays free, and the agentic actions like Distill and Consolidate are part of a one-time $49.99 license. Your Anthropic key is only used for those in-app AI actions and lives in the Keychain. Site with the full tier breakdown and screenshots: https://memophant.co Curious how others here are handling Claude Code memory today. Are you living in CLAUDE.md, leaning on /memory, or something else? What breaks for you? submitted by /u/awizemann [link] [comments]

agentsweep: a CLI that finds & redacts the secrets your AI coding agent saved to disk in plaintext

Every time you paste an API key, DB URL, .env file, or (worst case) a crypto wallet seed phrase into Claude Code, it gets written to a local history file in plaintext. And it doesn't just sit there — these agents re-read their own history as context, so that plaintext key keeps getting fed back to the model and can resurface in a later file, command, or reply. Most people never even look. agentsweep is an open-source CLI that: • Scans those history files with ~191 secret-detection rules (ported from gitleaks) plus a dedicated BIP-39 seed-phrase detector • Supports ~30 agents out of the box (Claude Code, Cursor, Codex, Cline, Aider, Windsurf, and more) • Redacts in place with atomic writes, .bak backups, post-write validation, and a full undo Read-only by default; nothing destructive happens without a typed confirmation, and every redaction is reversible. Install: pipx install agentsweep (then run: agentsweep) MIT licensed, repo: https://github.com/Ishannaik/agent-sweep Happy to answer questions or take PRs for more agents. submitted by /u/Ishannaik [link] [comments]

Want to see what our brand-new GitHub FC kit will look like on you? We've developed cutting-edge technology so you can see exactly how it will fit. https://t.co/S8LhjjSKrZ https://t.co/C51X5wKtZo

Want to see what our brand-new GitHub FC kit will look like on you? We've developed cutting-edge technology so you can see exactly how it will fit. https://t.co/S8LhjjSKrZ https://t.co/C51X5wKtZo

Your standards. Your tools. Every review. Copilot code review supports custom agent skills and MCP server connections. Now in public preview for existing Copilot Pro, Pro+, Business, and Enterprise u

Your standards. Your tools. Every review. Copilot code review supports custom agent skills and MCP server connections. Now in public preview for existing Copilot Pro, Pro+, Business, and Enterprise users. Bring your org's context and standards right into the diff. 💡 https://t.co/cAuIkVClEm

RT @cinnamon_msft: In honor of PowerToys' 100th release, I created a Canvas in the GitHub Copilot app to visualize the release notes! The…

RT @cinnamon_msft: In honor of PowerToys' 100th release, I created a Canvas in the GitHub Copilot app to visualize the release notes! The…

Different countries, different backgrounds, one team. Coding is a team sport. And now we have the kit to match. Check out our GitHub FC jersey and match ball 👇 https://t.co/dVYcyJVE3b https://t.co/

Different countries, different backgrounds, one team. Coding is a team sport. And now we have the kit to match. Check out our GitHub FC jersey and match ball 👇 https://t.co/dVYcyJVE3b https://t.co/abQS8UMcs7

I built a CLI that scans your Claude Code history for leaked API keys and redacts them in place open source, fully offline (Python)

The problem Claude Code stores your full conversation history as plaintext JSONL under ~/.claude/projects/. Every API key, DB password, and .env file you've ever pasted into a chat is sitting there in plain text. A single compromised npm package running postinstall can scan common paths and exfiltrate everything in one request. I reviewed my own history and found 3 AWS keys and a Stripe secret key I'd forgotten about entirely. What I built agentsweep a CLI that scans AI agent history files and redacts secrets in place. How it works 189 detection rules (AWS, GitHub PATs, Stripe, OpenAI, Anthropic, Slack, JWT, PEM keys, DB URLs with passwords, BIP-39 crypto seed phrases, and ~167 more ported from the gitleaks pack) Aho-Corasick keyword pre-filter before regex and fast even on large histories Supports 10 agents: Claude Code, Codex, OpenCode, Cursor, Windsurf, Aider, Cline, Gemini CLI, Continue, GitHub Copilot Chat Atomic writes + mandatory .bak backup before every change agentsweep undo reverts any redaction instantly Zero network calls it runs entirely on your machine Install pip install uv && uv tool install agentsweep && asweep Interactive menu walks you through everything. Type REDACT to confirm — nothing destructive happens without an explicit confirmation. Who is this actually for If you use local agents (Aider + Ollama, OpenCode with a local model, etc.): Your keys never left your machine via the agent, but they're sitting in plaintext files that any process on your machine can read. A compromised npm package, a malicious VSCode extension, a stolen laptop. The local file is still an attack surface even if the network never saw it. If you already pasted keys into cloud-backed agents (Claude Code, Cursor, etc.): Yes, the provider already received those keys, agentsweep can't undo that. But your local history is a separate, ongoing attack vector. Cleaning it up removes one more way those keys can be stolen, long after the conversation ended. The honest framing: The best practice is to not paste production keys into any AI agent at all. This tool exists for the reality that most devs already have histories full of secrets they pasted months ago without thinking twice. GitHub: https://github.com/Ishannaik/agent-sweep Happy to answer questions about rule coverage, false positives, or agents I haven't added yet. submitted by /u/Ishannaik [link] [comments]

No more waitlist. The GitHub Copilot app's technical preview is available to everyone currently on Copilot Pro, Pro+, Max, Business, and Enterprise plans. ⬇️ https://t.co/n9kL7XLDjS

No more waitlist. The GitHub Copilot app's technical preview is available to everyone currently on Copilot Pro, Pro+, Max, Business, and Enterprise plans. ⬇️ https://t.co/n9kL7XLDjS

Every context switch has a cost: new window, new branch, "wait, where was I?" The GitHub Copilot app keeps the whole loop in one place from issue to merge. https://t.co/somvVaxL7C

Every context switch has a cost: new window, new branch, "wait, where was I?" The GitHub Copilot app keeps the whole loop in one place from issue to merge. https://t.co/somvVaxL7C

RT @leereilly: Late to the game, but I finally took the GitHub Copilot app for a spin tonight… wow. In a few prompts & few minutes, I had…

RT @leereilly: Late to the game, but I finally took the GitHub Copilot app for a spin tonight… wow. In a few prompts & few minutes, I had…

GitHub Agentic Workflows are now in public preview. Intelligent automations for GitHub, with strong guardrails, observability, and cost controls. Start automating today 👇 https://t.co/Z3Zcx48om8 htt

GitHub Agentic Workflows are now in public preview. Intelligent automations for GitHub, with strong guardrails, observability, and cost controls. Start automating today 👇 https://t.co/Z3Zcx48om8 https://t.co/TQAJWqNmSn

Secure access to internal apps, without a VPN. That's @pomerium_io, an open-source reverse proxy that uses identity and context for authentication, authorization, and zero trust access. This Friday,

Secure access to internal apps, without a VPN. That's @pomerium_io, an open-source reverse proxy that uses identity and context for authentication, authorization, and zero trust access. This Friday, learn how it works and when to use it instead of a VPN. Set a reminder 🔔 https://t.co/uYhuxEPpPv

No more waitlist. The GitHub Copilot app's technical preview is now available to everyone currently on Copilot Pro, Pro+, Max, Business, and Enterprise plans. This agent-native desktop experience let

No more waitlist. The GitHub Copilot app's technical preview is now available to everyone currently on Copilot Pro, Pro+, Max, Business, and Enterprise plans. This agent-native desktop experience lets you decide what agents work on, how they work, and what ships. Go from issue https://t.co/Mww5yS6cig