I build skeptic systems — software designed to validate its own reasoning, not just return a result.
My focus is on:
- Decision-Aware Orchestration: Systems that justify how they think before they act.
- Foundations over Features: Building the infrastructure that makes AI reliable, not just "smart."
- Evolutionary Architecture: Software that expects requirements to shift and data to age.
I believe good software is less about perfect outputs and more about decision hygiene, explicit trade-offs, and verification.
I’m building AI foundations and infrastructure that solve the "black box" problem:
- Agentic Flow of Thought (FOT): Implementing dynamic strategy selection (REACT vs. THINK) to make agent reasoning transparent.
- Skeptic Research Pipelines: Multi-agent systems that actively seek contradictions and score evidence credibility.
- Local-First & Specialized AI: Production-ready pipelines for niche languages (Hebrew) and local-first execution (Ollama/ivrit-ai).
- Audit & Traceability: Append-only logging and RAG-based knowledge reuse that remembers why a system made a choice.
Everything is shared openly — code, design, and documentation — so others can learn, reuse, or evolve it.
- Designed for change, not completion
- Stable core, flexible edges
- Safety by construction (DB-level guarantees > application promises)
- Explicit trade-offs over hidden magic
- Documentation is part of the system
If a system can’t explain itself, it’s already decaying.
I work across backend, cloud, and infrastructure layers, with a heavy focus on reliable AI systems, multi-agent orchestration, and long-term maintainability.
A sophisticated multi-agent research system with a 9-agent pipeline. It features automated quality assurance, contradiction seeking, and a persistent knowledge base using pgvector and RAG.
- Stack: FastAPI, Celery, Redis, PostgreSQL, AWS Bedrock (Claude 3.5 Sonnet).
- Core: 3,000-6,000 word reports with deep technical depth.
An AI agent framework for asynchronous survey simulation based on predefined personalities. It utilizes DSPy for robust LLM orchestration and Agent Flow of Thought (FOT) for dynamic strategy selection.
- Stack: DSPy, Pydantic, Ollama, OpenRouter, ClickHouse (analytics).
- Core: High-fidelity persona simulation and consistency testing.
An automated, production-ready audio transcription and analytics pipeline specifically optimized for Hebrew. Features speaker diarization and real-time folder watching.
- Stack: FastAPI, Celery, faster-whisper (ivrit-ai models), pyannote.audio.
- Core: Multi-stage enrichment (transcription -> diarization -> analytics).
A multi-tenant, append-only audit logging service built with Postgres RLS, Keycloak, and explicit evolution docs.
- Why it exists: To demonstrate how to design infrastructure that survives change and maintains strict DB-level guarantees.
- Backend architecture
- Infrastructure foundations
- Systems that outlive their authors
- Simplicity that comes from clarity, not shortcuts
- Thoughtful discussions about system design
- Collaboration on infrastructure-level projects
- Reviewing or exchanging design ideas
If you care about how systems age, we’ll probably get along.