AI orchestration developer and full-stack systems engineer.
I design the connective tissue between models, tools, agents, codebases, and users.
My work sits at the point where software systems need to stay understandable while becoming more intelligent: context engineering, knowledge graphs, agent workflows, developer tooling, and interfaces that make complex behavior feel clear.
AI context infrastructure
Memory systems, repository-aware knowledge graphs, agent workflows, tool routing, and evaluation loops for AI-assisted development.
Full-stack systems engineering
Interfaces and component systems that survive real product constraints: accessibility, localization, timezones, testing, state flow, and edge-case behavior — plus the API contracts underneath them.
Developer experience
Build tooling, CI parity, reusable workflows, documentation, and automation that makes teams faster without hiding important complexity.
redlib-mcp — a private window into public Reddit for AI agents
A Model Context Protocol server that reads public Reddit through a self-hosted Redlib instance: no Reddit login, no tracking, nothing leaving your machine. Three parts that work together — an MCP server exposing four read tools, a cross-platform CLI (setup, restart, update, doctor) that builds and operates the backend from a pinned upstream commit, and a setup skill that lets an agent drive the CLI itself. Open source and published on npm.
Repo-aware knowledge graphs for AI assistants
I adapted Graphify — a knowledge-graph tool by Safi Shamsi at Graphify Labs — for a large multi-package monorepo where the upstream assumptions did not fit the host environment. The useful work was not a direct install; it was the reconciliation layer around it:
- package-level graph storage instead of a single repo-root graph
- sequential, resumable extraction for an assistant without background workers
- graph routing by closest package path
- tracked Git hook automation for affected-package rebuilds
- deep, directed graph defaults
- setup and doctor scripts for local verification
- a hard boundary between the durable summary layer and volatile per-package graph state, so the two context layers never overwrite each other
Persistent context for AI-assisted development
I designed a two-tier context protocol for an AI coding assistant: durable project summaries at the repo root, volatile execution state scoped per package. It helps the assistant preserve project context across sessions, follow repository conventions, and stop rediscovering the same architecture every time.
Production front-end systems
I have built and hardened component systems with keyboard accessibility, timezone correctness, localization, Cypress coverage, Storybook documentation, and careful state modeling.
Most of my building runs through a six-stage loop, with a subagent fan-out in the middle and a review pass that is allowed to reject the result:
assemble_context() -> forge_spec() -> write_plan() -> fan_out() -> scrutinize() -> distill()
Context first, because a plan written against a half-read codebase is confidently wrong. Spec before plan, so the acceptance bar exists before the work does. Fan-out because independent agents catch what one pass misses. Scrutinize before distill, because the interesting failures are the ones a single author cannot see in their own work.
The bottleneck for useful AI tooling is often not model capability. It is context quality.
A capable model still performs worse when it has to spend its working memory reconstructing architecture from scratch. I like building the systems around the model: the memory, graph structure, routing rules, verification steps, and human-facing interfaces that turn intelligence into something durable.
The theme I keep returning to:
Flow under control.
Make hidden state explicit. Route context correctly. Verify the boundaries where systems drift.
- Website: grazomarin.com
- GitHub: @grazomarin