Engineering judgment before model novelty

I build AI systems with a product engineer's bias for useful behavior and a platform engineer's bias for explicit boundaries.
My profile picture

I'm Andrei Ksianzou, an AI engineer and product architect with more than a decade of experience shipping web products and evolving the systems behind them.

My path started with client websites and PHP integrations, moved through large frontend migrations, design systems, and enterprise application architecture, and now centers on AI products and agent infrastructure. That history is useful: it makes it easier to separate genuinely new capabilities from old engineering problems wearing a model-shaped hat.

What I bring to AI engineering

  • Agent-system architecture — model routing, tool contracts, durable workflows, clarification, verification, repair, and approval gates
  • Governance by construction — explicit capabilities, scoped secrets, sandbox boundaries, audit evidence, and deny-by-default external effects
  • AI product delivery — translating probabilistic model behavior into understandable workflows, measurable acceptance criteria, and maintainable code
  • Platform experience — architecture and standards across a suite of 50+ applications, including cross-team technical strategy
  • Frontend depth — complex editors and dashboards, a 70+ component design system, and incremental modernization of legacy applications
  • Developer experience — build and release automation, typed contracts, observability, documentation, and feedback loops that help teams move faster safely

How I approach the work

I start by identifying what must remain deterministic: authority, budgets, data boundaries, retries, approvals, and acceptance evidence. The model is then used where judgment and synthesis add value — inside those boundaries.

Current focus

I am building Cadrune, a security-first framework for embedding governed agent systems into different products and operational domains. Its core runtime is written in Rust; coding and other domain heuristics live in composable TypeScript packages and extensions, with Python and Go SDK boundaries for integration.

The project explores a practical question: how much autonomy can we safely make useful when permissions, model choice, durable state, evidence, and external effects are first-class parts of the architecture?

If that question is relevant to what you are building, tell me about the problem.

© 2026 Andrei Ksianzou