Hey, I'm Pavel. I build control planes for messy engineering work.

Fintech infrastructure. Agentic tooling. Markets-shaped frontend/platform work. The cross-repo, half-owned problems where things either quietly work — or become very expensive.

Lately I live in the layer between "chat with a model" and "trust an agent with real work": routing, memory, cost control, review gates, and reusable execution patterns.

Start with Pi-Rogue ↓

Current Build

Pi-Rogue

My command-plane for deliberate AI execution.

Pi-Rogue is where I prototype the missing control layer around agents: advisor checks, model routing telemetry, context brokerage, Fusion-style model panels, and explicit goal/loop orchestration — in plain English, fewer wasted tokens and less blind agent wandering.

The rule is simple: do not send every token to the smartest model; do not let every agent run blind; do not treat context as infinite.

Route cheap work to cheap models, escalate when the decision deserves it.
Compress and broker context with ctx:// handles instead of shoving the whole session back into the prompt.
Compare models in panels, extract consensus and contradictions, then synthesize deliberately.
Let longer flows run with goals, review gates, stop conditions, and an audit trail.

Pi-Rogue page GitHub

Current Themes

Token efficiency

Routing, local/OSS models, vendor harnesses, model capability cards, benchmarks, and advisor calls only where the decision actually deserves an expensive brain.

Context engineering

Session memory, compact artifacts, hot/warm/cold tiers, and rehydration on demand. Token soup is not a strategy.

Longer autonomous flows

Goal loops, advisory preflight, review gates, stop conditions, and traceable execution instead of "agent, please go forever."

Pattern mining

Small models doing janitor work over real harness sessions and git history: surfacing repeated rituals, forgotten skills, and patterns worth turning into tools.

What I Ship

I like the kind of work that cross-cuts seven repos owned by four different teams and has no clear owner. The stuff that sits in the backlog because nobody knows where to start. That's the fun part.

Took vendor interview/scoring from vague backlog shape to shipped system before Christmas. No overtime. AI where it compounded, not where it looked cool.
Tax compliance changes at scale. Lost count of how many countries at this point. The kind of work that's invisible when it works and catastrophic when it doesn't.
Eternal hunt for fiscalization logic gaps — real monsters live on this trail.
TradingView-shaped work taught me useful paranoia: performance matters, correctness matters, and users notice when a chart, tick, or interaction lies.

AI Practice

I'm past the "can it generate code?" phase. The interesting part now is execution control.

How do I route cheap work to cheap models and escalate only when needed? How do I keep context alive without dumping the whole session back into the prompt? How do I let agents run longer without letting them drift, loop, or mutate everything? How do I mine repeated session patterns into reusable skills instead of rediscovering the same ritual every week?

Some stuff

Pi-Rogue — route, compare, arbitrate, and carry forward useful context.
TradingView MCP/tooling — market data piped into the agent loop, because charts are more useful when the harness can ask questions back.
Non-disruptive permissions started as a way to stop babysitting tools. The next move is spending fewer tokens, not just burning them faster.
Autoresearch on Apple Neural Engine — Apple silicon is fire, 109 experiments, autonomous gradient descent, had to see what it can do (24K views on Reddit).
Repo-Arch — local project memory from git history: mine commits into cards, evals, and training data so a repo can start explaining itself.

Currently

Shipping Pi-Rogue and Repo-Arch, tightening the token budget, testing alternative models, and making longer agent runs less feral. Touching grass when the harness allows it. Compounding.