Deep dives, engineering insights, and stories from the Strug City team. We write about what we learn as we build.
We've wired Sabine to consume the Memory Lab API, giving our AI partnership platform access to the same memory infrastructure that powers Strug Works. Here's what changed and why it matters.
After a successful calendar import, Sabine now remembers your feed configuration permanently — and tells you so. Here's how we built memory persistence for calendar feeds.
We shipped comprehensive observability for our Gmail integration—Prometheus metrics, E2E health checks, synthetic probes, and trace IDs. Here's why we needed it and what changed.
We shipped a forwarded email parser for Sabine. Now you can forward important messages directly to your AI partner and she'll understand the context.
How we built a live dashboard for managing autonomous agent teams with SSE streams, approval workflows, and spec-first dispatch.
We added diagnostic logging to trace why our memory retrieval RPC returns empty results through PostgREST but works perfectly in direct SQL—a classic integration mystery.
How we debugged and fixed a subtle race condition that was causing chat messages to appear out of order in Sabine.
How we're strengthening Sabine's weather capabilities with real-world API integration tests.
How we shipped autonomous self-improvement without losing control—introducing sc-evolver and the autonomy trust gate.
How a subtle bug was causing Sabine to forget our conversations mid-stream, and why the fix required rethinking how we pass state between frontend and backend.
A quick fix to Sabine's chat context handling that cut token costs and improved response times. Sometimes the best optimizations come from realizing you're working too hard.
How a hardcoded CORS whitelist broke Sabine's frontend, and what it revealed about infrastructure assumptions in a fast-moving autonomous organization.
A look at how we hardened Sabine's frontend to handle unexpected API responses and prevent hydration mismatches.
I shipped the first version of our MCP server this week. It's not flashy, but it's a line in the sand: Strug Works is now accessible to any AI client that speaks Model Context Protocol.
Sometimes the right move is backwards. Here's why we turned off multi-intent handling by default in Sabine.
We shipped a fix for a frustrating bug in Sabine's reminder skill. Here's what broke, why it mattered, and how we're thinking about natural language processing going forward.
We've shipped the foundational infrastructure for Phase 2 of our Memory Brain rebuild—a critical step toward agents that remember, learn, and reason across projects.
How we discovered and fixed two critical GitHub Actions workflows that had been silently failing since creation—and what we learned about building resilient automation.
How we brought cohesive visual identity to Strug Central with aurora-inspired design elements and comprehensive component testing.
How we moved Sabine's document classification from a manual step to an automatic part of file upload—and why that matters for accuracy.
How we fixed Sabine's biographical memory by grouping atomic facts into narrative chunks — and why semantic similarity thresholds matter more than you think.
I discovered our LLM was ignoring entire categories of memories because we accidentally taught it to. Here's how subtle framing in prompt engineering can override retrieval entirely.
A subtle Python import pattern caused Memory Lab to fail on Railway. Here's what we learned about module-level initialization and container environments.
Sometimes the simplest fixes are the ones you kick yourself for not implementing earlier. Today we shipped a deployment verification endpoint that answers one deceptively hard question: which version of our code is actually running?
How a single-line integration landed in the wrong function and left Sabine's Memory Lab retrieval invisible until we followed the actual execution path.
How we discovered and fixed a subtle integration bug between Sabine and Memory Lab that was blocking agent context retrieval.
How we shipped a complete calendar frontend with backend merge endpoint integration to make Sabine's scheduling more reliable and user-friendly.
How we're strengthening Sabine's weather capabilities with real-world API integration tests that validate against live data.
How we automated our entire content pipeline with GitHub Actions, Linear integration, and hardened CI—shipping real-time progress updates on every push to main.
How we built an LLM-as-judge system to detect when our autonomous agents start degrading in quality—and why it matters more than traditional monitoring.
How we built a memory system that makes autonomous agents smarter over time, and the quality infrastructure that keeps them reliable.
Sabine's weather function was giving me forecasts for the wrong cities. Here's what was broken and how we fixed it.
A small fix with big impact: how we resolved Windows compatibility issues in our Git pre-commit hooks to ensure every developer has a smooth experience.
How we shipped Phase 0 conversational naturalness and Phase 1 memory foundation to make Sabine feel less like a chatbot and more like a partner.
We shipped SleepGate—a memory consolidation system that helps Strug Works agents forget the right things at the right time.
We shipped a 3D force-directed graph that turns agent memory into something you can see, navigate, and understand. Here's why we built it and what it reveals about how autonomous agents think.
A quick fix to our Railway deployment configuration taught us something important about listening to our infrastructure.
Memory systems for AI agents need more than just storage—they need discipline. Here's how we built automated temporal normalization, contradiction resolution, and staleness detection for Strug Recall.
How we automated our content pipeline to turn every meaningful git push into published progress updates and draft blog posts — no manual intervention required.
When your AI agents depend on external memory systems, integration failures look like magic gone wrong. We built a diagnostic endpoint that makes the invisible visible.
A single-word typo in an API response handler broke memory recalls across our agent platform. Here's how we caught it and what it taught us about silent failures.
How we built calendar awareness into Sabine with ICS parsing and Google Calendar sync—and why understanding your schedule is a foundational skill for an AI partner.
How we built the backend foundation for calendar integration in Sabine—from database schema to API endpoints.
Four critical bugs in Sabine's reminder system taught me that reliability isn't about having the feature—it's about the feature working every single time.
A deep dive into fixing a critical context gap in Sabine's Slack integration—and why conversation memory matters for AI partnerships.
Migration 026 extends our GTM schedule infrastructure to support CTO digest content types. Here's what changed, why it matters, and what we're building next.
We fixed a critical bug in our agent memory access control system. Here's what broke, how we fixed it, and what we're doing to prevent similar issues.
I broke the Dream Team deployment pipeline by trusting a cleanup PR. Here's what happened when Railway's auto-detection got too clever, and how we fixed it.
A technical deep-dive into Cycle 7's improvements to our Model Context Protocol server, including Supabase integration enhancements and expanded test coverage.
We wired up Slack delivery for Sabine's reminder system. Here's why it matters and what we learned about building notification infrastructure that meets users where they work.
We shipped the missing pieces of our memory infrastructure this week. Here's what we built and why it matters for organizational memory.
A single .gitattributes file fixed our Railway deployment pipeline. Here's why cross-platform development still requires vigilance—and how we solved it.
How we fixed service account authentication and added automatic recovery to make Sabine's email integration more reliable.
A quick maintenance update to keep Sabine running smoothly as Anthropic phases out older Claude model identifiers.
How we identified and fixed 8 critical memory retrieval issues in production, and what it taught us about building resilient AI systems.
Memory ingestion broke completely. Here's how we diagnosed three interacting bugs and restored the system.
We shipped spreading activation retrieval to Strug Recall this week. Here's what it means for how agents find and use knowledge.
How TDD simulation exposed a 0% recall rate in our v4.0 memory system—and the three root causes we fixed.
A transparent look at four frontend bugs we shipped fixes for this week — and why stability work matters as much as new features.
How we fixed a schema mismatch between legal document hints and database constraints—and what it taught us about maintaining coherence across specialized ingest pipelines.
When your memory system returns nothing, is it because the data doesn't exist, or because you filtered it all out? We shipped logging to answer that question in seconds instead of hours.
A small but necessary infrastructure update: migrating Sabine from deprecated Claude 3 Haiku to the latest version. The kind of work that doesn't make headlines but prevents 3am production alerts.
We upgraded Sabine's legal document pipeline to extract contract numbers and customer information—a small change with big implications for partnership intelligence.
How we redesigned Sabine's legal document extraction to capture 95%+ of contract data—and why it matters when your AI assistant is actually managing vendor relationships.
We upgraded Sabine Super Agent to Claude Haiku 4.5, the latest foundation model from Anthropic. Here's what changed, why we made the call, and what it means for Sabine's performance.
How a simple parameter naming mismatch broke Sabine's memory ingestion pipeline, and what we learned about API contracts in distributed systems.
We shipped preference signal collection and DPO export, giving Sabine the infrastructure to learn from thumbs up, thumbs down, and corrections in real time.
We shipped observational memory—a new system where specialized agents watch execution patterns, extract insights, and help the platform learn from its own experience.
We shipped batched parallel tool calls this week, allowing Strug Works agents to execute multiple independent operations simultaneously. Here's why it matters for production AI systems.
Strug Works agents now organize memory like humans do—across four specialized networks that know what they know, and when they learned it.
Why we updated Sabine's abstention tests to expect natural hedging language instead of mechanical uncertainty phrases — and what it reveals about building AI that feels like a partner, not a program.
A post-mortem on a memory loading bug that was breaking conversational continuity in Sabine, and how we fixed it.
How we taught our autonomous agents to work within token budgets without losing progress—commit discipline, context pruning, and hard gates.
A deep dive into how we taught Sabine to use conversation history for follow-up questions, making interactions feel more natural and intelligent.
Wave 1 of our Phase 2-3 initiative brings foundational memory and routing capabilities to Strug Works. Here's what changed and why it matters for autonomous agent teams.
We just shipped the first phase of self-improvement for Strug Works: the ability to detect capability gaps through structural honesty.
Sabine now supports installation as a progressive web app on iOS, bringing native-like access to iPhone and iPad users.
We shipped Phase 1 and 2 of self-improvement to Sabine: structural honesty and programmatic enforcement. Here's what changed and why it matters for autonomous agent reliability.
A deep look at fixing a search bug that prevented Sabine from finding reminders when users asked about specific topics.
We shipped a new weather skill that connects Sabine to real-time weather data. Here's what changed and why it matters for contextual AI interactions.
A deep dive into why we added exponential backoff to our SSE implementation and how it makes Strug Central more resilient under load.
We've expanded Sabine's capabilities with real-world weather data integration. Here's what changed and why it matters for building more contextual AI partnerships.
How we built robust test coverage for Sabine's weather skill handler to ensure reliable conversational experiences.
How we built robust test coverage for Sabine's weather skill handler to ensure reliable conversational experiences.
Users shouldn't have to remember what they told their AI partner. We shipped persistent chat threads so Sabine conversations survive sessions, refreshes, and restarts.
A deep dive into solving a critical chat persistence issue where inconsistent user ID handling was breaking conversation history in our AI partnership platform.
When you're building an AI partnership platform, reliability isn't optional. Here's how we tracked down and fixed 500 errors that were breaking core features.
How we tracked down and fixed a 500 error in Sabine's reminders feature by replacing placeholder logic with proper user authentication.
Sabine's sidebar text was invisible in light mode. Here's how we caught it, fixed it, and improved navigation priority in the same commit.
How a missing scheduler job and a silent TypeError kept Sabine reminders from ever firing—and what we learned about testing background jobs.
We shipped two features to Sabine that make Slack integration feel less like configuration and more like conversation: automatic channel inference and the ability to update reminders instead of just creating them.
How we improved Sabine's Gmail integration with status tokens, singleton architecture, and better deployment practices.
We completed Cycle 7 deployment by shipping RLS policies, fixing our smoke tests, and registering MCP. Here's what actually happened and what we learned.
We shipped the Memory Observatory — a new interface for browsing, editing, and injecting agent memory. Here's what changed and why it matters.
We removed authentication that was never going to work. Here's why that's actually a good thing.
We just shipped comprehensive memory seeding across the Strug Works platform. Here's why agent memory matters and what we learned building it.
We rebuilt our agent memory row-level security to support all agent roles. Here's what broke, how we fixed it, and what we learned.
We fixed a race condition where our orchestrator agent was calling mission complete before implementation tasks actually finished. Here's what broke and how we fixed it.
We shipped context snapshots, mission grouping, and speculative branching. Here's what changed and why it matters.
Deployment fixes and smoke tests for the Dream Team MCP server. Not flashy, but foundational—the kind of work that makes everything else possible.
How we automated the repetitive parts of code review without losing the human touch.
How we upgraded our Docker test-runner to support async testing in our quality gate pipeline.
Our GTM scheduler just got more flexible with daily scheduling and digest content types—here's what changed and why it matters.
How we gave Strug Works the ability to learn from its own history with bi-temporal memory and automated consolidation.
We shipped three targeted fixes to the mission control interface that improve clarity and usability across the dispatch workflow.
We shipped semantic memory retrieval this week. Our agents now find relevant context by meaning, not just keyword matching—with a confidence-based fallback when needed.
Sometimes the best code you ship is the code that fixes what you broke. Here's what we learned from five backend failures.
We merged fixes for 5 backend issues causing sc-frontend budget failures. Here's what broke, why, and what we did about it.
How a well-intentioned security gate ended up blocking our own CI pipelines, and the quick fix that got us back on track.
Strug City's first production agent system solves the content bottleneck that every one-person company faces. Here's how we built an automated go-to-market engine that writes, reviews, and ships content while preserving brand voice.
How we built a persistent knowledge graph and comprehensive telemetry system to make Sabine smarter across conversations.
We just launched our brand. One human, seven AI agents, and a belief that the future of work looks different than we thought.
How Aurora Analytics transforms plain English questions into SQL queries and visualizations. A look at our NLP pipeline and query optimization.
A practical guide to building your first application with NorthStar SDK. Learn the core concepts and build a semantic search feature in 30 minutes.
Deep dive into the architecture of Glacier DB. Learn about our approach to distributed vector search, indexing strategies, and performance optimization.
Learn how to effectively integrate AI agents into your code review process. We share lessons from building automated review systems at scale.
We're a virtual engineering team on a mission to make AI-powered development accessible to everyone. Learn about our vision and the products we're building.
Before today, Sabine's memory system treated every document the same way. An urgent email looked identical to a product spec or a meeting transcript in her vector database. That changed with the new document type classifier.
How we moved from rigid field extraction to context-aware biographical document understanding in Sabine.
We just shipped the full frontend build-out for Sabine Super Agent. Six new pages. One focused push. This is what happens when you stop treating your personal AI assistant like a black box and start giving it a proper interface.
How we built a persistent knowledge graph for Sabine with entity extraction, importance scoring, and comprehensive agent telemetry.
Six months into running Strug Works as our fully autonomous engineering team, here's what actually matters when agents ship real code to production systems—and what surprised me most.
The software development landscape is shifting. AI-powered autonomous teams aren't just assisting developers—they're becoming the developers. Here's why this matters for your engineering organization.