Spent the last several months building on top of every major AI coding tool — Cursor, Claude Code, Devin, Copilot.

The pattern that keeps breaking things isn't hallucination. It's statelessness.

The agent doesn't know you reverted that database migration six weeks ago because it caused cascade failures under load. It doesn't know your team's postmortem concluded that pattern was permanently off-limits. It has no concept of why the codebase is the way it is — only what it currently looks like.

The result: architecturally confident, syntactically clean, operationally dangerous output. It passes review. It ships. Then it breaks something you've already broken before.

I'm building Linor — an AI Engineering OS designed around the premise that agents need institutional memory, not just code context. A few specific things it does that I haven't seen elsewhere:

— Déjà Vu alerts: Before any agent executes, it checks the Wisdom Graph (a temporal knowledge graph built from commit history, reverts, PR discussions, and ADRs) for similarity to historically regressed patterns. If a proposed change mirrors something your team already rolled back, it surfaces the original postmortem before a single line is written.

— Blast Radius Heatmap: Risk-scores every plan and visualizes exactly which files, modules, and systems are in the blast zone before execution is approved.

— Shadow Simulation: High-risk changes run in a gVisor-isolated sandbox — full network egress controls — before they ever touch your actual codebase. You see the outcome before you approve it. — Watcher AI: A continuous probabilistic auditor that intercepts agent actions mid-execution — not post-commit. Flags spec deviations, hallucinations, style violations, and blast radius breaches in real time.

— Automated ADR generation: When the Manager AI makes a significant architectural decision, it drafts an Architecture Decision Record, surfaces it for approval, and commits it into your repo docs. Institutional memory that compounds.

— Bus Factor analysis: Detects dangerous ownership concentration across modules — which parts of your codebase only one person (or one agent session) really understands.

— Self-Healing CI/CD: When a build fails, a DevOps/QA Worker is triggered automatically to diagnose and remediate — without you opening a terminal.

— Vibe Style Enforcement: The Watcher enforces your team's architectural philosophy (functional vs OOP, verbosity, testing stance) — not just linting rules, but paradigm-level consistency.

— Intelligent Trash + Quarantine Recovery: Every Worker-initiated deletion is captured with full retention. If an agent deletes something that later causes a failure, semantic recovery traces the deletion and restores it.

The underlying architecture is a three-agent triad: Manager AI (persistent orchestrator with long-horizon memory), Watcher AI (pre- and mid-execution auditor), Worker Agents (ephemeral specialists — Backend, Frontend, DevOps, QA, Security).

The Manager survives sessions. Your context doesn't die when you close the tab.

Currently pre-launch, targeting senior engineers on production-grade codebases who've stopped trusting their AI tools because the tools have earned that distrust.

Genuinely curious: what does your team currently use? What's the failure mode that pushed you to build workarounds — CONTEXT.md files, manual checklists, approval gates? And is there anything in the above that you'd call solved already by a tool I'm missing?