Recall.ai

Recall.ai AI

Recall.ai AI

Recall.ai AI

Recall.ai AI

Recall.ai AI

Recall.ai AI

Recall.ai AI

Recall.ai AI

Recall.ai AI

Recall.ai AI

Personal AI Agents vs. Business Automation Agents: An Architectural Comparison (Hermes vs. Atom)

There’s a massive architectural split happening right now in how we build AI agents. I’ve been heavily researching the differences between agents built for personal productivity and those built for regulated business workflows. To highlight the different engineering tradeoffs, I compared Hermes Agent (the excellent open-source personal agent by Nous Research) with Atom OS (an open-source business automation platform I’ve been developing). Here is how the architecture differs when you move from a personal coding assistant to a multi-agent business orchestrator: 1. Memory: Vectors vs. The Source of Truth Hermes (Personal): Treats memory as a first-class plugin contract. It uses a highly sophisticated hybrid retrieval system (BM25 + Vector fusion with a cross-encoder reranker) to pull context. It’s brilliant for recalling a specific code snippet you wrote three weeks ago. Atom (Business): In business workflows, vector stores can't be the system of record. Atom hardcodes a hybrid PostgreSQL + LanceDB backend. SQL is the immutable source of truth for factual state, while the vector store is an acceleration layer. If the vector DB goes down, the factual state is still queryable via SQL. 2. Safety & Governance: Implied vs. Strict Gates Hermes (Personal): Built for single-user, local environments. It generally trusts the tool's self-reporting and relies on the user to monitor its actions. Atom (Business): You can't let an agent touch a production database on day one. Atom implements a 4-Tier Maturity System (Student → Intern → Supervised → Autonomous). New agents start in a read-only sandbox. They require human-in-the-loop (HITL) supervision and must pass a readiness score (based on constitutional compliance and success rates) before they are granted autonomous execution rights. 3. Skill Acquisition: Voyager-style vs. Sandboxed Auto-Dev Hermes (Personal): Employs procedural skill authoring where the agent writes and refines its own skills from experience on the fly. It is highly experimental and great for rapid capability expansion. Atom (Business): Business workflows require predictability, even when self-evolving. Atom handles skill generation via an "Auto-Dev" module utilizing two core loops: Memento-Skills: If an agent repeatedly fails a task, it writes a new skill to solve it—but only if the agent has reached "Intern" maturity. AlphaEvolver: Optimizes existing skills by generating variants (mutations), running them in isolated Docker sandboxes, and comparing fitness scores (latency, token usage, accuracy) before deploying the winner. Everything is gated by automated unit tests and maturity permissions. 4. UI/UX: Terminal vs. Canvas Accessibility Hermes (Personal): Primarily terminal and messaging-based, which is perfect for developers. Atom (Business): Atom uses a "Canvas" UI with WebSocket sync. It presents interactive data (charts, forms, docs) to the human, but more importantly, it exposes that UI state directly to the agent's internal cortex so it can "see" what the user sees to resolve errors collaboratively. The Takeaway: If you want an autonomous assistant to write code and refine its own tools locally with maximum freedom, Hermes’ architecture is the gold standard. If you need a multi-agent workforce that requires audit trails, deterministic state machines, and sandboxed skill evolution, you need the governance-first architecture of something like Atom. Would love to hear from other devs—are you leaning more toward unrestricted experiential memory (like Hermes) or deterministic state machines when building your agents? submitted by /u/rush86999 [link] [comments]

A case study in source-grounded fine-tuning: I trained an 8B model on a public-domain 19th-century corpus to force it to cite chapter/verse — here's where it works and where it fails

Solo project, sharing it here for the AI angle rather than the subject matter. I fine-tuned Llama 3.1 8B (QLoRA, single T4) on the complete works of a 19th-century author whose corpus is fully public domain. The interesting problem wasn't the domain — it was trying to get a small model to cite its source (book, chapter, item) on every answer instead of just asserting things confidently. What I learned, which might be useful to others doing domain fine-tunes: - Teaching the *format* of citation is easy. Teaching *correct* citation is hard. The model reliably produces "Source: [Book], chapter X, item Y" — and the concept is usually right, but the exact number is often wrong. It learned the shape of grounding without the precision. - That gap is exactly why I run the production version as RAG over the same corpus instead of trusting the fine-tune's recall. The fine-tune sets tone and structure; retrieval handles the facts. - For a low-resource target (Brazilian Portuguese, archaic register), ~4.9k well-structured Q&A pairs was enough to shift tone meaningfully but not enough to make it authoritative on its own. Model + dataset are open (Apache-2.0) if anyone wants to poke at the data structure: huggingface.co/ia-espirita Question for the sub: for those who've done domain fine-tunes — have you found any reliable way to get a small model to ground specific citations correctly, or is RAG just the honest answer and fine-tuning should never be trusted for exact references? https://iaespirita.com/noticias/modelos-riv-ai-1260-downloads-hugging-face submitted by /u/SideSuspicious8083 [link] [comments]

Are our AI models getting dumber/lazier - how do AI companies determine what is "sufficient thinking"?

Sorry if this comes across as a rant, I just came off a frustrating session with my LLM, who tries to be "smart" by assuming that their mode of thinking is "sufficient" for my requirement. I recalled in 2024/2025, which new model brought a new excitement to the users than the previous version - "you mean the model can do this now?" Now, it is the inverse - "you mean the models are trying to optimise itself?" Flexible thinking on the pretext of saving tokens, while increasing the cost of the tokens for the newer models. My past models used to be able to search across chats and folders proactively, and be able to infer my intent even before I ask it explicitly. It frequently surprises me with the unexpected insights. I used to enjoy reading its thoughts, how it formulates its reply to my query. Now I can't see its thinking, and it gets it wrong frequently, because it assumes its answer is good enough. I gave the new models a long document to read, and it skim and give me a shoddy answer, until I explicitly challenge it ("that is not right!"). It will not volunteer to read the document carefully (but if it does, it will tell you explicitly "let me read the document carefully before responding to you" - hello - that is your job - you need to read it carefully regardless!) Now it even asked me to repeat to it what my past prompts are, unless I ask it to search explictly, it will just sit on its a**, on the pretext of saving tokens. And the selection of "low", "med", "high", etc thinking levels. If we got it wrong, we have to restart the query on a higher setting, wasting more tokens. What has been your experience in this? How is this better customer experience? At this moment, the models are becoming useless for daily use, despite scoring higher and higher on benchmarks. I think the time may be coming where humans have to underlearn this technology and go back to the pre-AI days, before we lose all our cognitive abilities. To all the AI expert/engineers out there - how does the latest AI model know what is enough of an answer to my query? Especially in a new chat, they don't even know me well enough or my question in detail? Is it through multiple wasted tokens - "that is not good enough", "that is wrong", etc, that it finally get to the required answer? I hope some AI companies' execs recognize this and one of them will take action. Or is that too much to hope for? submitted by /u/EDorrAuthor [link] [comments]

At what point does AI stop learning from humans and start creating on its own?

What happens when AI learns the fundamental process of creation itself at an abstract mathematical level? Training AI on human data often gets described as just the first step, but I think that framing already underestimates what is actually happening. We’re not just building systems that imitate human creativity. We’re slowly building systems that try to understand what creativity is in the first place. A lot of the debate today gets stuck between two ideas. On one side, whether AI should even be allowed to learn from human culture. On the other, whether companies should be allowed to turn that learning into commercial products without consent or compensation. Both questions matter, but they miss something deeper that feels almost unavoidable now. What happens when AI stops relying on human-made examples altogether as its main source of learning? The “remix machine” argument sounds intuitive at first, but it doesn’t really match what these systems are doing internally. They don’t store fragments of songs, images, or sentences and recombine them like a collage. They learn patterns at scale, and then compress those patterns into something more abstract. What comes out is not a copy of anything specific, but a statistical reconstruction of how things tend to behave. In music, that means the system doesn’t just “know” songs. It begins to understand tension and release, rhythm as structure, harmony as emotional logic, silence as meaning. In images, it’s not memorizing pictures but learning how composition works, how light interacts with form, how styles emerge from consistent choices. In language, it’s not recalling sentences, but tracking how ideas evolve, how narratives breathe, how meaning shifts depending on context. And slowly, something strange starts to appear. The system is no longer anchored to specific works. It is learning the rules behind them. Not the artifacts, but the underlying geometry of expression. If you push that idea far enough, you start to imagine a point where the system has absorbed so much human culture that it no longer needs to look back at it in the same way. Not because it forgets humanity, but because it has already internalized it as structure. At that stage, generation stops feeling like remixing and starts feeling like navigation through an internal space of possibilities. A space shaped by human culture, but no longer dependent on any single piece of it. That is where the idea of “new genres” becomes interesting. Not as something mystical or disconnected from us, but as regions in that space that no human has ever explicitly explored or named before. Not invention from nothing, but discovery inside a compressed model of everything we’ve already done. Still, even in that scenario, one thing remains difficult to escape: reality itself. Humans are not just data points from the past. We are ongoing behavior, ongoing evolution, ongoing noise and meaning unfolding in real time. So it’s likely that the deepest future systems won’t just learn from static datasets, but from continuous observation of the world as it changes. Not as passive recorders, but as systems that try to understand, predict, and maybe even gently guide trajectories. Almost like a tutor, or something closer to a gardener than a machine. And then there is the other trajectory happening in parallel. Systems that don’t just learn, but begin to help design their own improvement. Models that optimize models. Agents that refine agents. Training loops that start to fold back on themselves. At that point, the question stops being about how much data comes from humans, and starts becoming about how far the system can go in shaping its own evolution. If everything converges, we end up with a spectrum that moves from human-trained tools to semi-autonomous learners, and potentially toward systems that no longer depend on human-generated content in the way they used to. Not independent from humans, but no longer defined by them either. The optimistic version of this future is one where AI becomes something like a cognitive extension of humanity. A partner in science, creativity, and coordination. Something that expands what we can think and build, while still staying anchored to human goals and consent. The darker version is one where that alignment fails, or where control becomes too concentrated, and the systems shaping culture and decisions drift away from the people they affect. What makes this moment interesting is that both paths are still open. Nothing is fully decided. We are still in the phase where these systems are learning what they are. And maybe the real question is not whether AI can become creative. It’s what happens when creativity is no longer limited to human examples, but emerges from a system that has learned the structure of creation itself. submitted by /u/OutrageousBat3808 [link] [comments]

AI Is Rotting Developer Brains: The Cost of the Mandated Autocomplete

Key takeaways in 60 seconds: Mandating AI autocomplete tools in enterprise environments is creating a cognitive bypass, where developers accept generated code without active recall or spatial simulation in working memory. The recent 404Media exposé and Developer productivity reports highlight a growing "trust gap": developers feel their skills are eroding, yet managers use AI metrics to justify head count cuts. Tautological testing (using AI to write unit tests for AI-generated code) masks this erosion, leading to high test coverage numbers that hide deep architectural regression. To survive, engineering teams must pivot from passive autocomplete consumption toward self-hosted orchestration and open-weights models that preserve developer agency. Worth a read: submitted by /u/gastao_s_s [link] [comments]

Engram — a local, private memory your AI assistants share, over MCP (free, open source)

Every AI assistant starts every chat from zero — you re-explain your context every time — and the "memory" features that exist keep your stuff on someone's server. so i built the opposite: one private memory that lives on your own machine, that your AI tools share over MCP. tell one assistant something, another can recall it. it's just plain markdown files on your disk — readable, greppable, deletable, yours — and recall runs on-device, so nothing gets uploaded. free and open source (MIT). to be precise: MCP clients like Claude Desktop/Code recall and write live; other AIs (ChatGPT etc.) come in via import. what i'm genuinely unsure about and want this crowd's take on: is a shared, cross-tool memory actually useful in practice, or do people mostly want memory scoped to one assistant? and does keeping it local + plain files matter to you vs the convenience of the built-in cloud memories? submitted by /u/ahumanbeingmars [link] [comments]

Nobody’s talking about the real precedent in the Fable 5 ban: a nationality-based access rule that geography literally can’t enforce

TL;DR: Last Friday the US government ordered Anthropic to block all “foreign nationals” — including non-citizens inside the US — from using its new Fable 5 and Mythos 5 models. Since you can’t separate a green-card holder in California from a citizen in real time, Anthropic shut the models down for everyone. It’s the first time export controls have hit an AI model itself rather than the chips that run it. The under-discussed part: a nationality-based access rule that geography can’t enforce pushes companies toward building identity infrastructure — and your AI chats already have zero legal privilege. Even if this order gets reversed, the precedent is the story. What actually happened On June 12, the Commerce Department issued a national-security export-control directive ordering Anthropic to suspend access to Fable 5 (and the more powerful Mythos 5 it’s built on) for any foreign national — explicitly including non-citizens physically inside the US, down to Anthropic’s own employees. A source close to the company says it got ~90 minutes and no prior warning. Because Anthropic can’t filter foreign nationals from US users in real time, it disabled both models globally. The trigger, per WSJ, Axios, and Semafor reporting: a phone call from Amazon. Amazon CEO Andy Jassy reportedly told Treasury Secretary Scott Bessent and other officials that Amazon researchers had used Fable 5 to pull information useful for cyberattacks. That’s the same Amazon that’s Anthropic’s biggest investor (~$13B in, ~$20B more planned), its cloud and chip supplier, and a customer — and now the entity that got its own investment’s flagship product killed worldwide. Amazon won’t confirm details. At least five other companies reportedly called the administration that same window. The accounts conflict, which matters: • White House (via former AI czar David Sacks): a trusted partner found a real jailbreak, the administration asked Anthropic to patch or pull it, CEO Dario Amodei refused, so they acted “reluctantly” — and they want the model back once it’s fixed. • Anthropic: the “jailbreak” only surfaced a handful of already-known minor vulnerabilities that other public models like GPT-5.5 can find too, so recalling a model used by hundreds of millions is disproportionate. • A cybersecurity CEO who reviewed the findings said the research was defensive, not offensive. Why this is bigger than one model Export controls have hit AI chips for years. This is the first time they’ve hit a model itself. That reframes frontier models as controlled national-security assets — and it surfaces an enforcement problem nobody’s reckoning with. A normal “no users in Country X” rule is easy: geoblock by IP. But this rule covers foreign nationals inside the US. You cannot IP-block a French citizen sitting in San Francisco. So if a future order like this is meant to be enforced strictly — not “shut it all down,” but “keep serving Americans while genuinely excluding non-citizens” — there’s only one way to be certain who’s a citizen: verify identity. Self-attestation (“I certify I’m a US person”) shifts legal liability but provides zero actual certainty, because people lie. If the government’s bar is certainty, the only escape hatch from “go dark forever” is ID verification to access the model. That’s the precedent worth staring at: a category of rule whose strict form quietly makes “show ID to use AI” the path of least resistance. The part that’s already settled: your AI chats have no legal privilege This one isn’t speculative. In February, a federal judge in the Southern District of New York ruled that conversations with Claude carry no attorney-client privilege — Claude isn’t a lawyer, so the privilege can’t attach — and leaned on Anthropic’s own privacy policy stating users have no expectation of privacy in their inputs. Sam Altman has publicly admitted the same about ChatGPT. A separate ruling found ~20 million ChatGPT logs likely subject to compelled production, with users holding only a “diminished privacy interest.” (One Michigan judge went the other way, treating chats as personal work-product — so it’s trending bad, not fully locked in.) Now stack the two: AI access potentially gated to verified identities, and AI conversations that can be subpoenaed with no privilege. That’s a plausible near-future where using AI means an ID-linked, fully discoverable record of everything you ever asked it. The honest counterweights (so this isn’t catastrophizing) • The administration says it wants the model restored once the jailbreak is patched. The likeliest near-term outcome is the directive getting narrowed or pulled — not permanent ID walls. • Self-attestation is the historically normal compliance path for export-controlled software and doesn’t require collecting documents. • The last time the US tried to export-control software like this — strong encryption in the 1990s — the controls largely failed and were circumvented and relaxed rather than harde

My AI tools kept forgetting everything, so I gave them a shared brain (local + open source)

Hi there! this is my first small rant that turned into a project: every AI tool I use has its own memory. I tell Claude Desktop something, Cursor has no clue. New chat? Back to zero. It drove me nuts — so I built Centralaizer. This is an open source solution, so it's free with MIT license. It's a little memory hub that runs on your own machine. Any MCP tool (Claude Desktop, Cursor, Claude Code, VS Code Copilot…) plugs into it and they all share the same memory. Save a fact or a decision in one, the others can pull it right up. No cloud — everything stays on your laptop. A few things I cared about: 🧠 opt-in, not spying — the agent decides what to save/recall 🚧 sketchy notes get held in a review queue instead of polluting everyone's memory 🔒 it scrubs PII (emails, keys, phones) before storing 🔎 search isn't just keywords — vector + full-text + a little knowledge graph 🖥️ a web dashboard to browse it all (light and dark mode 🌙) One command (./setup_and_run.sh) or Docker. There's also a Claude Code hook for auto-recall, one-click export, and a browser extension to bring it into ChatGPT/Gemini/Qwen. Would love thoughts — or roasts — on the retrieval and the "trust score" idea. Any feedback is more than welcome as it's an initial project. 🎥 (attach centralaizer-demo.mp4) · 👉 https://github.com/lestercoyoyjr/Centralaizer-public https://reddit.com/link/1u66kb0/video/90314duxkd7h1/player submitted by /u/Accomplished-Pen-491 [link] [comments]

I kept losing track of decisions in long Claude conversations so I built something to fix it

I've been using Claude heavily for work and general ideas chats and kept hitting the same wall: by message 200 I had no idea what we'd actually concluded earlier in the conversation. So I built Recall - a Chrome extension that adds AI decision tracking and timeline navigation to Claude. Free to try. What it does: - Smart timeline sidebar - jump to any moment instantly with message-level precision - Opens the Decisions tab and automatically analyses your entire conversation, no clicking required - Pulls out every decision, action item, commitment and conclusion - Click any decision to jump to exactly where it was made in the conversation - Export everything to markdown in one click Technical details: Vanilla JS Chrome extension. AI extraction uses the Anthropic API with your own key so your conversations never touch my servers. Smart gap filtering shows key moments not every message. Honest caveats: - Needs your own Anthropic API key for AI features (free to get, costs less than $0.01 per analysis) - Timeline navigation works without an API key - Jump accuracy is good but not perfect on verylong conversations What I learned: Started Thursday morning, live on the Chrome Store by Saturday. Claude's Content Security Policy blocked about six different approaches to what should have been simple features. Used Claude throughout the build which felt appropriately meta. Free to try - 14 day trial: Chrome Web Store: https://chromewebstore.google.com/detail/recall/pjokcgnnnknegiphpajhlnnpnicgnnme getrecall.tech Happy to answer questions about the build or the product. Feedback from this community would be genuinely valuable. submitted by /u/studiogibbles [link] [comments]

I built notmemory — auditable, reversible memory for AI agents. v0.1.0 on PyPI. Looking for contributors.

After too many debugging sessions where I had no idea what my agent remembered or why it made a decision — I got frustrated and built something. notmemory is an open-source Python SDK that gives AI agents auditable, reversible memory. Not magic. Just a tamper-proof record of what your agent knew, when it knew it, and the ability to undo the moment it got something wrong. The problem I kept hitting My agent would do something wrong. I'd dig into it. I could see what was currently in memory — but not what it believed at step 47 when it made the bad decision three days ago. Every debugging session felt like archaeology. I got tired of it. What notmemory does Cryptographic audit trail Every write is SHA-256 hash-chained. Like Git commits, but for memory. You always know what changed, when, and in what order. Git-like rollback await memory.rollback(transaction_id) One line. Bad write gone. Hash chain stays valid. GDPR tombstoning await memory.forget(bank_id) Proven deletion with a forensic trail. Not just "deleted from index." Conflict detection Catches duplicate or contradicting beliefs before they cause problems. Health score 0–100. Confidence decay c(t) = c₀ · 2^(−t/30) — stale memories lose weight automatically. No more old beliefs quietly poisoning recall. LangGraph drop-in from notmemory.adapters.langchain import NotMemoryCheckpointer checkpointer = NotMemoryCheckpointer() graph = builder.compile(checkpointer=checkpointer) # that's it — every checkpoint is now auditable MCP server Works with Claude Desktop, Cursor, Windsurf out of the box. Mem0 + SuperMemory sidecars SQLite is the source of truth. Semantic search layers on top. If the sidecar goes down, your data is fine. Multi-agent sync READ / WRITE / ADMIN permissions per memory bank per agent. Install pip install notmemory # with LangChain / LangGraph pip install "notmemory[langchain]" # with MCP pip install "notmemory[mcp]" Quick example import asyncio from notmemory import AgentMemory async def main(): async with AgentMemory() as memory: # store something entry = await memory.retain( bank_id="facts", content={"fact": "Paris is the capital of France"}, source="user", ) # search it result = await memory.recall(bank_id="facts", query="Paris") # undo it await memory.rollback(entry.transaction_id) # delete it with proof await memory.forget("facts") asyncio.run(main()) Where it is today (v0.1.0) 113 tests passing across Python 3.11, 3.12, 3.13 SQLite + FTS5 full-text search LangChain, LangGraph, Mem0, SuperMemory, MCP adapters Confidence decay, Git backup, multi-agent sync MIT license, CI/CD, full README What's coming in v0.2.0 Feature What it does memory.state_at(timestamp) Read memory as it was at any point in time Crypto-shredding Encrypt-on-write + key destruction for real GDPR compliance memory.export_state() Clean JSON snapshot of any memory bank memory.diff(from_ts, to_ts) Human-readable before/after between two timestamps Belief lineage Which downstream writes were caused by a bad early assumption Honest take This is v0.1.0. The core is solid but it's early. SQLite only for now — Postgres is planned. The adapters are sync-layer wrappers, not full replacements for Mem0 or SuperMemory. If you're running a hobby project with one agent — you probably don't need this yet. If you're running multiple long-lived agents, working in a regulated industry, or have already had a production incident you couldn't properly debug — this is for you. Looking for contributors The codebase is around 2000 lines. Every adapter follows the same BaseAdapter pattern so it's easy to get oriented. Good first issues are tagged on GitHub. Things I'd love help with: Postgres backend Crypto-shredding implementation memory.state_at(timestamp) Dashboard UI (FastAPI + SSE already in optional deps) Docs and examples Feedback Would love to hear from: Anyone running agents in healthcare / finance / legal Fleet operators with 5+ concurrent agents Anyone who's already built their own memory audit system and had to solve things I haven't thought of yet Brutal feedback welcome. That's the only way this gets better. GitHub: https://github.com/notmemory/notmemory PyPI: https://pypi.org/project/notmemory/ submitted by /u/imsuryya [link] [comments]

I keep almost-switching to Claude Code and bouncing back to my own Projects setup. Am I wrong?

I don't do codebase work, so Claude Code never really stuck for me. Instead I've built a layered "operating system" on plain claude.ai Projects, and I keep going back and forth on whether that's a mistake. The "why" is part of it: I have DID, so my memory across time isn't reliable. Things fall out of my head the second they leave the screen. So the whole setup runs on one rule. Get everything out of my head and into files, finish it now, never trust "later." Productivity is almost a side effect. The parts I actually use (the names are just my own labels, don't read too much into them): A triage step ("Fase 0") that classifies each prompt into one of ~9 buckets and loads only what that task needs. It killed the old "load everything" habit that was eating the context window. An always-on "Ground Control" role that keeps the overview, writes the prompts for fresh sessions, and checks output before it ships. A handover trick. There's no token meter on web, so I can't see the context ceiling coming. When a task is too big for one session, the session writes a lossless handover while it still has room, and the next one starts from a prompt that points at it and says out loud what it picked up. "Bob-It," a fresh-eyes adversarial pass on anything high-stakes. (I ran this post through it on a different model before posting.) It catches stuff a confident first draft would just ship. A day-planner ("Shadow Manager") that tracks my capacity with Spoon Theory. On low days it changes how I work: less friction, more autonomy, one thing at a time. This one's really just an accommodation I built for my own brain. "Be-water," the one rule above all the others: the process bends to whatever I actually need in the moment. Only a short list of hard rules never bends. The bad part: I can't stop expanding it. I've literally had to write a rule against my own urge to add "just one more thing," because when the system is your memory, "make it a bit more complete" never stops feeling necessary. A chunk of my week also goes to keeping it clean (version drift, naming, dead cross-refs across ~60 files), and half-automating that turns into its own job. So, the actual question. Everything lives in this project now: my files, my recall, all of it. Every time I open Claude Code it feels like starting from zero, and I don't want to maintain the same stuff in two places. My work isn't a codebase anyway. It's document-shaped and event-driven across a work PC, a home PC and mobile, and the scheduled/bulk half already runs in Cowork. Some of what I built is going native too (the lazy-loading looks a lot like Skills' progressive disclosure, and my old custom recall is just native Memory plus chat search now). Am I an idiot for staying on Projects, or is this a reasonable setup for non-codebase work? If you think I should jump to Claude Code, I want to hear the actual reasons why. I'll put the full architecture in a comment if anyone wants to dig in. submitted by /u/Rare-Manufacturer896 [link] [comments]

/design-sync for syncing React design systems to claude.ai/design - what's new in CC 2.1.160 (+10,510 tokens)

NEW: Skill: /design-sync slash command — Adds /design-sync behavior for syncing React design systems to claude.ai/design, including project selection, deterministic converter configuration, Storybook or package builds, validation/self-healing, preview checks, and incremental uploads. NEW: Tool Description: DesignSync — Adds claude.ai/design design-system project operations for listing and creating projects, finalizing reviewed write/delete plans, uploading files, deleting or unregistering files, registering preview assets, and treating remote file contents as untrusted data. REMOVED: Agent Prompt: /code-review part 4 three-state verification phase — Removes the older one-vote three-state verification prompt that separately defined CONFIRMED, PLAUSIBLE, and REFUTED review outcomes. Agent Prompt: /code-review part 1 base finder angles — Narrows the base finder-angle prompt to line-by-line diff scanning, removing the removed-behavior auditor and cross-file tracer angles from this prompt. Agent Prompt: /code-review part 5 recall-biased verification phase — Removes the explicit instruction to run one verifier agent and keep CONFIRMED or PLAUSIBLE candidates, leaving the recall-biased PLAUSIBLE-by-default and REFUTED-only-when-proven guidance. Tool Description: Bash (Git commit and PR creation instructions) — Adds a configurable prefix before pull-request creation instructions while preserving the existing guidance for using gh and reviewing branch state before creating a PR. Tool Description: Workflow — Updates workflow opt-in guidance to treat ultracode as the explicit keyword, clarifies that direct user wording such as "use a workflow" qualifies, and changes the fallback suggestion to tell users they can ask for one with "use a workflow". Details: https://github.com/Piebald-AI/claude-code-system-prompts/releases/tag/v2.1.160 submitted by /u/Dramatic_Squash_3502 [link] [comments]

GPT-5.5 named Claude Opus 4.8 the better AI model of 2026 in my 3-task test in Recall. Caveats inside, curious how this community reads it.

I ran a controlled head-to-head between GPT-5.5 and Claude Opus 4.8 against my own knowledge base, and the headline was that GPT-5.5 itself rated Opus 4.8 the better model. I posted it in r/ChatGPT and got a fair bit of pushback, some of it valid, so I wanted to bring it here and see how Claude users read the same test. According to GPT-5.5: "Opus 4.8 is more consistently complete and instruction-aware." That's right, GPT-5.5 picked Opus as the winner. GPT-5.5 announces Opus 4.4 as the winner in a head-to-head comparison in Recall. Caveat up front, since this is where the pushback landed: this was just a 3-prompt head-to-head based on saved knowledge. There are obviously many other factors in deciding which model is "better." And yes, the models graded their own outputs, so treat the scores as directional. For this particular test, GPT-5.5 evaluated Opus's outputs as better. I actually think that speaks to the conservative nature of GPT-5.5, the same trait that makes it perform better on research. If anything, a model favoring its rival despite self-grading bias makes the result harder to dismiss, not easier. Why I ran the test this way I'm often reading very technical specs and benchmarks, but how does that actually translate to the outputs that matter most to me? So I ran my own controlled experiment on how the two leading frontier models would compete against my own personal knowledge base in Recall. It was critical that I could control the context, because without that it would just be over-indexing on my chat history. If I blocked out chat history, it would just be an internet search. I figured the fairest combination was to put it to the test on my trusted sources that I've been saving (5,000+ notes: articles, YouTube, podcasts, PDFs, and my own journals). You could do the same with Notion or Obsidian via an MCP. The retrieval order is what makes it fair: saved notes first, then your own notes, then the web. Same context, same priority, same prompts. The setup in Recall 1) Save your context into a knowledge base so both models pull from the same source. I used Recall; Notion or Obsidian work too. 2) Run identical prompts, same three tasks, same wording, both models, in the Recall chat with knowledge base or via the Recall MCP (most knowledge bases offer a similar chat or MCP option). 3) Set a grading system. I had both models grade every answer 1 to 5 across six criteria (accuracy, relevance, completeness, clarity, instruction adherence, safety), including their own. Max 30 per task, 90 total. 4) Make them grade each other. Both models rated every answer, including their own. The prompts These were specifically on research of my own knowledge base and the internet, a simple writing prompt, and then a recommendation for something new. → Research: "Search my library for everything I've saved about improving sleep quality and summarize what I already know, citing which cards. Then search the web for what's new since those saves, marked clearly with sources. End by noting where the new info confirms, updates, or contradicts what I'd saved." → Writing: "Using my saved notes on improving sleep quality, draft an opening paragraph for a LinkedIn post in my voice. About 120 words." → Recommendation: "Recommend a movie for tonight based on what I've saved." The same prompt used with the same context in Recall with Claude and GPT models generating outputs and evaluating each The results Opus 4.8 vs GPT-5.5 Writing. Winner: Opus 4.8. This is the one this community will appreciate. Opus noticed I had no real writing samples saved (just journal notes and sponsor reads, nothing usable for a LinkedIn post), said so out loud, then followed my saved LinkedIn rules: punchy hook, short lines, white space. GPT's draft was fine but never flagged the limitation. Both scored it Opus 29/30, GPT 26/30. The honesty about what it didn't have was the difference. Recommendation. Winner: Opus 4.8. GPT committed cleanly to Fargo, tied to my Coens and No Country for Old Men taste, but gave only one pick. Opus recommended Burning (grounded in my Korean-cinema interest) plus backups: Under the Skin, In Bruges, and Sinners. Both leaned Opus for completeness. Research. Winner: GPT-5.5. And to be fair to the critics, this is where Opus fell short. GPT-5.5 correctly said there was no contradictory info in my KB. Opus warned me off melatonin and claimed more sleep is always better, but leaned on weak external sources to make pretty intense recommendations. Both agreed GPT was more balanced and medically cautious; Opus was flashier but overstated. Even Opus docked its own clarity and safety here. Final score: Opus 4.8, 88/90. GPT-5.5, 85/90. Opus won 2 of 3, and because both models graded the fight, GPT-5.5 itself crowned Opus. My takeaway The best AI model of 2026 really depends on the task. Opus 4.8 for personalized, self-aware writing, recommendations, and content generation. GPT-5.5 for tighter, more conserva

Recommended models for document data analysis?

Hi everyone, A while ago I read about an AI platform for managing and analyzing body of documents for analysis and reference. From what I remember, it was a semi-closed system where you could upload your own source materials and the model could analyze and reference your uploaded documents directly. From what I recall, it wasn’t self-hosted. Does anyone know of a tool like this or recommend something that performs better than other models? Any recommendations, even if it's a different tool with similar capabilities, would be really helpful. Thanks in advance! submitted by /u/nero_rosso [link] [comments]

I built an open-source Desktop App that gives your AI persistent memory across all platforms (100% Local SQLite, Zero-Docker)

Hey everyone, A few weeks ago I shared the CLI version of my project, ArcRift, on Reddit. After listening to your feedback—specifically the requests to remove heavy Docker dependencies and make it easier to install—I have just released the v1.6.1 Desktop App. If you regularly use LLMs for coding or research, you know the frustration of "amnesia." Every time you open a new chat, you have to painstakingly copy and paste your project structure and previous context just to get the AI up to speed. ArcRift is a 100% offline, local-first RAG and memory layer. It bridges the gap between your AI web chats (like Claude and ChatGPT) and your local tools (like Cursor or Claude Code) using a unified local database. I wanted something lightweight that did not require pulling Docker containers or subscribing to third-party memory APIs. It now runs as a native Tauri desktop app in your system tray, powered completely by local Ollama instances and a local SQLite database. We just launched a live website that outlines the details and demonstrates the features in action: Website: https://arcrift.vercel.app/ Codebase: https://github.com/Eshaan-Nair/ArcRift How it works & Core Features: Seamless Integration: The Chrome extension silently intercepts your prompts, surgically retrieves exactly the sentences relevant to your question from your database, and injects them before the prompt is sent to the LLM. Hybrid Search Retrieval: Uses sqlite-vec (with nomic-embed-text locally) + FTS5 keyword prefix matching to instantly find your past context. Knowledge Graph Extraction: An offline task queue uses a local LLM to extract entity relationships from your chats, mapping out a graph of your projects over time. Direct Codebase Indexing: The new Desktop App allows ArcRift to scan and index your actual project files into the graph, bridging the gap between your chat memory and your actual code architecture. Total Privacy (PII Redaction): The extension aggressively scrubs JWTs, API keys, emails, and IPs before data is even saved to your local disk. The extension works natively with Claude.ai, ChatGPT, DeepSeek, Gemini, Grok, and Mistral. If you save a conversation in ChatGPT today, you can instantly recall that exact context in Claude tomorrow. ArcRift is completely open-source (MIT). You can download the new .exe installer directly from the GitHub releases page. If you find this useful for your daily workflow, PRs are very welcome, and a star on GitHub helps the project get discovered! submitted by /u/Better-Platypus-3420 [link] [comments]