sokel.exe

Agree that remembering is the part most tools still don’t really ship. I’d probably define “memory” more broadly here though: not just past messages, but persistent project state, permission history, approval decisions, traces, and model/runtime constraints. That persistent state is what makes it an operator, not just a session.

@sokelabs memory's the only one on that list that has to survive a restart. the rest gets rebuilt every session, the remembering is the part nobody ships

Building a personal AI operator made me realize the model is not the product. The real product is the runtime around it: memory permissions tool use approval flows project context execution traces fallbacks when local/cloud models are not enough That’s where personal AI gets interesting.

@spanlens The Postgres-backed fallback queue is the most interesting part to me. When replaying failed writes into ClickHouse, did you need ordering + dedup guarantees, or was eventual consistency acceptable for LLM log ingestion?

Just wrote up the 5 gotchas I hit moving Spanlens's LLM logs from Postgres to ClickHouse. DateTime64 quirks, silent number-to-string coercion, deploy ordering, and a Postgres-backed fallback queue. dev.to/spanlens/5-got… #buildinpublic #devtools #llm #postgres #clickHouse

I added a small sokel-zip command to my terminal. 
 It packages the current project into a clean zip while respecting .gitignore. 
 No node_modules, no env files, no build junk. 
 Tiny automation, but it removes a surprisingly annoying workflow friction.

@arynnsgh That separation makes a lot of sense. I’ve been seeing the same issue in agent memory experiments: semantic similarity often looks like memory, but breaks on factual precision and project-specific context. How do you decide what goes into vector memory vs graph memory?

@sokelabs Working on agent memory too. One thing worth separating: working memory (in-context), episodic memory (vector store), and semantic memory (knowledge graph). Most RAG setups conflate the last two, which kills retrieval precision on long-running agents. Happy to compare notes.

I’m building around AI workflows, agent memory, retrieval systems, and automation. Looking to connect with people working on: agents RAG / retrieval AI observability workflow automation developer tools product-focused AI systems Say hi if this is your area too 👋

@rahulsinghh__ Nice to meet you Rahul. This fits well into indie dev launch workflows. Store screenshots are a small thing, but they slow shipping down a lot. Are you planning templates or AI-assisted generation by app category?

@sokelabs Hi Sokel, its Rahul here. I’m building Biscuit 🐶, a dead simple App Store and Google Play screenshots maker. For indie developers/solopreneurs who wants to ship fast 🚀 Looking to connect with fellow builders 🤝🏻 meetbiscuit.com

@debojyoti452 Nice, this sounds like a full email infra layer. The CLI + sandbox mode part caught my attention. Are you mainly targeting developers/startups who want a simpler alternative to SendGrid/Postmark?

Hii, Building keplars.com - an email infrastructure platform focused on making setup and tracking much simpler. Unifies transactional and marketing email with OAuth sending, custom domains, built for both tech and non-tech users. Setup time? 5 clicks. here are the features: - Email API - SMTP - Webhooks - SDKs for 11 languages - Real-time email tracking after sent, open time, delivered time, click time - email automations docs.keplars.com/automations with AI-generated templates - CLI docs.keplars.com/cli - unified email editor enceladas.com - sandbox mode for testing emails - Integrates with Firebase, Supabase, Vercel (Vercel Marketplace), Lovable, React Emails, PocketBase, PayLoad CMS, Zapier and more Pricing: keplars.com/price-calculat…

@ClaudeDevs This is a good example of AI coding tools moving from generation to inspectable workflow control. The important part is not only finding vulnerabilities, but deciding when to check: file edit, model turn, commit, or review.

We’ve shipped a security-guidance plugin for Claude Code that helps identify and fix vulnerabilities as you’re writing code. Available for all Claude Code users. Install from the plugin marketplace (/plugins).

Building a personal AI operator made me realize the model is not the product. The real product is the runtime around it: memory permissions tool use approval flows project context execution traces fallbacks when local/cloud models are not enough That’s where personal AI gets interesting.

@JustJerry121 Definitely. Memory without observability gets hard to trust fast. I’m especially interested in making retrieval decisions, conflicts, and context selection inspectable instead of treating memory as a black box.

@sokelabs Agent memory plus observability is a fun overlap to compare notes on.

That progressive disclosure approach makes a lot of sense. I recently started a full-time role working around BERT-based financial models for fund buy/sell decision support, so trading logic + automation + usable tooling is a very relevant intersection for me now. Happy to chat more.

@sokelabs @sokelabs Great question! We use a visual strategy builder with blocks for entry/exit/rules — simple for beginners, but you can nest conditions, add custom indicators & fine-tune params. Progressive disclosure: start simple, unlock depth as needed. Would love to chat more!

@flytradr_guy Nice, followed back. I recently started working around financial models, so trading automation and strategy tooling are especially interesting to me. Curious how you balance no-code simplicity with enough control for serious strategy builders.

@sokelabs Hey! Building FlyTradr — no-code algo trading platform. SaaS + automation. We use rules engines to automate trading strategies, so workflow automation and dev tools are very much our world. Followed!

@cponsart That makes sense. The “silent override” part is the key distinction. I’ve also found that treating memory as one ranking problem breaks down quickly; preference, decision, and project-state records need different retrieval and resolution behavior.

Recency is a signal, but not the primary policy. Fusion should be type-aware: a preference update, decision record, operating policy, and observation shouldn’t all compete on the same axis. A newer preference may override an older preference, but it shouldn’t silently override a decision record. It should create a conflict edge: “this preference contradicts this decision.” Then resolution depends on type, authority, scope, and approval state. So less “latest wins,” more “typed memory with provenance + explicit conflict handling.

ContextFit just hit 99.0% retrieval on LongMemEval-S n=500. The unlock: memory atoms + fusion. Instead of treating memory as one flat vector search problem, we route preferences, decisions, temporal updates, and open loops differently. Agent memory needs structure, not just more context.

@claudeai Currently building experiments around AI memory, local search, and inspectable workflows. I’m interested in what happens after the first demo works: retrieval quality, traces, evaluation, and making the system easier to trust.

What are you building?

Six Claude projects that all came from the same question: “why not?”

I’m starting to care less about “AI apps” and more about the systems around them. Memory policies, retrieval quality, validation, traces, fallbacks, latency, evaluation loops. The interesting work is not just calling a model. It’s making the workflow reliable enough to trust.

@pauliusztin_ Semantic search retrieves by similarity, not usefulness to the current goal state. Without ranking policies for recency, salience, task context, and lineage, agents get the most “similar” memory; not the memory they should actually trust.

We keep calling it “agent memory.” But most systems are just semantic search over conversation history. (Or even worse, files over conservation history) Real memory requires a unified memory layer. This is the architecture I keep coming back to when designing memory for agents. (And I typically use @MongoDB as the unified memory layer) Here’s the core idea: One graph. Three memory types. One ingestion pipeline. And this is how it works: 1/ Short-term memory → "What's happening now?" This is the live conversation state. A Conversation stores an ordered chain of Messages: FIRST NEXT This is the agent’s working memory during a session. 2/ Long-term memory → "What's true over time?" This is the durable knowledge graph. It stores: People Organizations Locations Events Objects Preferences Facts Documents + chunks All connected through typed relationships. 3/ Reasoning memory → "What worked before?" The system stores reasoning traces as graph structures. So the agent can query: Which tools were used What decisions succeeded What failed previously Which reasoning paths worked best The agent can literally traverse its own thinking history. But these are not isolated systems... Everything lives inside one connected graph. So the agent can trace lineage like: “We know X, Y, Z about Paul from Message A, Document B, and Conversation C.” The separation between memory types is mostly conceptual. Underneath, it’s one unified graph. This is why @MongoDB works well here because it stores: Documents Graph objects Metadata Vector embeddings Inside one operational system. Everything entering memory flows through: Extraction Resolution Embedding Deduplication Resolution normalizes names. Deduplication decides identity. Confusing those two will corrupt your graph. There are 2 pipeline entry points: Batch Ingestion Sources like: Substack YouTube LinkedIn PDFs Notes ... flow into long-term memory on schedules. Live conversations As the agent chats and reasons, short-term memory gets distilled into: Long-term memory Reasoning traces A nightly pipeline also re-processes recent nodes to improve normalization, detect duplicates, and discover new connections. Here’s the big takeaway: Agent memory is becoming a data modeling problem rather than just a retrieval problem. P.S. What is the design of your agent’s memory?

@bnafOg Hidden state debt” is a sharp framing. Consolidation without a ranking policy just compresses noise. The hard part is deciding what should survive sleep. Are you thinking of reset triggers as explicit lifecycle events, or derived from drift metrics?

'Language Models Need Sleep' is the agent-memory paper title everyone should steal as a product requirement. Long-running agents need consolidation, forgetting, and reset triggers or memory becomes hidden state debt.