I design and build developer platforms and infrastructure where systems remain explicit, composable, and predictable - without increasing cognitive overhead.

A deterministic multi-agent orchestration system for real software execution.

Instead of treating agents as autonomous chat participants, Ferrus models them as workers in a controlled lifecycle - with explicit state, enforced transitions, and restartable execution.

Focus: predictable, debuggable, production-aligned agent systems.

A low-level SDK for the wire protocol between applications and language model servers.

Svir provides explicit request encoding, streaming response decoding, transport, compatibility handling, and tool primitives while leaving orchestration and application state to the caller.

Focus: small, predictable protocol infrastructure without framework-level abstraction.

A production-oriented Model Context Protocol SDK for building structured AI systems.

Neva provides strongly-typed interfaces and predictable runtime behavior for integrating agents, tools, and services with minimal overhead.

Focus: bringing system design discipline into AI infrastructure.

A Rust web framework built around explicit HTTP abstractions and composable middleware.

Volga avoids implicit behavior and hidden execution paths, enabling systems that remain understandable under load and at scale.

Focus: clarity of reasoning without sacrificing performance.

An HTTP/3 engine built as a deterministic state machine.

Istok models protocol behavior explicitly, enabling testable, reproducible networking flows instead of relying on opaque runtime behavior.

Focus: protocol-level determinism and verifiable execution.

• Systems — distributed architecture, async runtimes, deterministic protocol design
• Platforms — developer platforms, cloud-native infrastructure
• AI — agent systems, MCP integrations, structured AI infrastructure

• Explicit architecture > implicit magic
• Composability > framework abstraction
• Performance as architecture
• Systems thinking over tool-driven development
• Solving real constraints over building abstractions for their own sake

Complexity is usually an abstraction problem, not a scale problem.

Hidden behavior — in frameworks, runtimes, and agent loops — is what makes systems hard to reason about.

I build systems where explicitness and ergonomics reinforce each other, from protocol-level infrastructure to AI orchestration.

Ongoing notes: engineering-notes

LinkedIn: https://www.linkedin.com/in/romanemreis