ghassan-ai-projects

Production-grade infrastructure for AI agents
Durable runtimes · shared agent memory · MCP-native data systems · the engineering practice that keeps them honest

Why this org exists

Agents are easy to demo and hard to operate. Everything here is built for the gap between the two: state that survives a crash, plans that are reviewed before they act, scores computed in code rather than asserted by a model, and evidence you can audit afterwards.

The projects are open for inspection, not just for use — architecture decisions, quality gates, and documented limitations ship alongside the code.

Start here → ScaleShop if you want something to try, ALMS if you want to read a control plane, automation-miner if you want to see a graded LLM pipeline that doesn't trust its own model.

🧱 Agent infrastructure

Runtimes and control planes — the layer underneath the agents.

Project	What it does	Stack
tamoz _{private · pre-release}	Ruby-native durable agent framework. An agent turn is a graph run over a SQLite checkpoint store: it survives `kill -9`, resumes from its last committed barrier, and reconciles an interrupted side effect from proven state rather than guessing. Nothing acts without a reviewed plan bound to its digest, and nothing touches a file without your approval. Nine gems, each installable with only its declared dependencies.	`Ruby` `SQLite`
alms	Agent Learning Management System — a self-hosted MCP control plane that fixes the fleet's worst failure mode: one agent learns something useful and the others never hear about it. Registry, heartbeats, gap-safe learning sync, OKF export, and protocol distribution by tag. Deliberately out of the hot path — agents keep working when it is down and resync later.	`Go` `PostgreSQL` `MCP`

⚙️ Agentic pipelines

Long-running multi-stage workflows with gates, evidence, and repair loops.

Project	What it does	Stack
film-pipeline-langgraph	Film creation from idea to validated handoff state. Typed graph state instead of loose dicts, real human approval gates via LangGraph `interrupt()`, artifacts that auto-version instead of overwriting, a living film matrix updated by downstream patches, and a QC subgraph that fans validators out in parallel via the `Send` API.	`Python` `LangGraph`
automation-miner	Give it any domain — a one-liner, a brief, or a whole knowledge-base folder — and it returns a ranked portfolio of ICE-scored automation opportunity briefs. Every claim is cited back to a numbered source chunk (`[S12] claims.pdf p.4`). The critic/refine loop is an LLM; the ICE math, coherence validation, and strategic filters are code. Nothing is silently dropped.	`Python` `LangGraph` `MCP`
berlin-insolvency-radar	Berlin sees 60–180 actionable corporate insolvencies a year, and analysts still sift court notices by hand. This scrapes the official portal, extracts structured facts, enriches from public sources, scores across five weighted dimensions, self-corrects on legal and evidence risk, and exports a ranked weekly newsletter — deterministic guardrails, full audit trail, fail-closed.	`Python` `MCP`

🔎 MCP-native knowledge systems

Data engines where the agent is the primary user, not an afterthought.

Project	What it does	Stack
email-intelligence-platform	Your Maildir becomes a continuously enriched knowledge base — FTS5, vector search, LLM-extracted facts, action items, and entities — all in one SQLite file. Agents get knowledge-level MCP tools (`find_waiting_replies`, `find_decisions`, `summarize_sender`), not a raw IMAP wrapper. No servers, no Docker, no UI.	`Python` `SQLite` `MCP`
orion-chess-db	A chess database with an MCP server built in, so agents can query and edit your games directly. Perft-validated legal move generation, lossless PGN round-tripping (variations, NAGs, Latin-1 legacy files), transposition-aware position search via Zobrist hashing, opening explorer, tactics detection, and player dossiers. Your database file is plain PGN — no proprietary format, nothing to migrate.	`Java` `MCP`

🎓 Learning by doing

Project	What it does	Stack
scaleshop-scalability-lab ▶ Try the live lab	Scalability is rarely solved by picking the most powerful technology — it is solved by finding the current constraint and accepting only the complexity the evidence justifies. Twelve progressive incidents: read the telemetry, cite the decisive signal, name the bottleneck, choose the smallest sufficient intervention, then compare against a reference architecture. All counterfactual — provisions nothing, sends no traffic.	`TypeScript` `Next.js`

🧭 How these projects are built

The same operating standard applies across the org — it is the point, not the packaging.

AGENTS.md in every repo — one operating contract, read natively by Claude Code, Codex, Cursor, and Gemini.
One command to verify everything — make check / npm run check: format, lint, typecheck, tests, build, product gate. If it passes locally, CI agrees.
Models propose, code decides — scoring math, validation, constraint overrides, and state transitions run in code. LLMs are never the arbiter of correctness.
Structured outputs, everywhere — schema-validated JSON at every stage boundary; parse failures retry with the error fed back rather than degrading silently.
Evidence over assertion — run artifacts, audit trails, citable source chunks, and an honest LIMITATIONS.md where one is warranted.
MCP-first — the agent is the primary interface. CLIs and UIs come second, if at all.