AI Consulting & Automation

I ship AI systems that pay for themselves.

I help teams put AI to work on real problems: automating the manual work that slows them down, making their documents answerable, and deploying systems that run reliably in production. Scoped, built and delivered end to end.

Have a process that should run itself?

Book a free consultation

Prefer writing? Reach me at eduardd.hv@gmail.com or call +421 950 774 038

Flagship

An AI employee for your whole company

One agent connected to all your tools that your team just chats with. See the live, interactive demo.

See the AI Employee
Case study

AI assistant for Masaryk University

Source-cited answers live on the university site. 15,362 graded runs, roughly 90 percent accuracy.

Read the case study

What I do

  • I automate the routine end to end, so it runs unattended and only pings a human when something actually needs one.

    You getprocess teardownbuilt and deployed pipelinealertinghandover doc

  • Ask in plain language and get the answer with the exact source cited, across everything you have ever filed.

    You getsearch over all your docscited answersaccuracy eval set

  • Hand off the whole process, not a chat window: the agent reads, researches, verifies and acts, and shows its work.

    You getscoped agent workflowguardrails and logshuman-in-the-loop review

  • The same leverage on your own hardware: private models, access controls, and nothing sensitive leaving the building.

    You geton-prem deploymentaudit logszero data egress

See it in action

Live, interactive demos of the systems I build: an agent pipeline, a working assistant run, and the stack it plugs into.

See it run

A document-intelligence task, start to finish: the agent works through the steps, and the results it produces are exactly what you get back.

agent · run
  • Reading 240 uploaded documents
  • Building vector index (VoyageAI)
  • Retrieving the relevant clauses
  • Cross-checking against the source
  • Drafting a cited answer
222
Documents indexed in the run
1.3s
Median time to a cited answer
93%
Answers traced back to the source

Why work with me

  • My own products in production: InzerPro (paying customers), NasadClaw and KouzelnikNaAkci. Not demos that die after the pitch.
  • RAG in the wild: vector search, BM25, MMR retrieval and LLM reranking, plus fact-verification so answers stay grounded in the source.
  • The unglamorous parts are handled: scheduled jobs that fire on time, Stripe billing with trials and failed-payment recovery, auth, rate limits, on-prem hardening.
  • Direct access to the builder. No layers, no handoffs, no account manager between you and the person writing the code.

How it works

  1. 01

    Discovery call

    A short call to find the specific bottleneck, who it hurts, and what a good outcome is actually worth in hours or money.

  2. 02

    Scope and fixed price

    A written scope with one clear deliverable, a timeline and a fixed price. You know exactly what you get and what it costs before we start.

  3. 03

    Build in the open

    I build in short cycles and show working software early, so we correct course while it is still cheap to change.

  4. 04

    Deploy and hand over

    It goes live in your environment, documented, with a handover so your team can run it without me on retainer.

Under the hood

How I actually build

AI does not ship production software on its own. These are live visualizations of a real, large-scale AI-assisted engineering effort, shown as an example of how I run the work: many agents in parallel, an adversarial reviewer hunting every bug, and nothing merged until it is green everywhere.

Adversarial review

One agent writes the code, a second agent is told to break it. This is how I keep AI-generated code honest before it ever reaches you.

✷ claude code · dynamic workflowadversarial review3 of the many bugs adversarial review caught before merge
bug 1 of 3 · the async close
✷claudeimplementer
its context: the .zig original, the port plan, its own reasoning
✷claudeadversarial reviewer
its context: only the diff. told to assume the code is wrong.
✷
src/runtime/api/bun/js_bun_spawn_bindings.rs · compiles clean
for stdio in [spawned_stdout, spawned_stderr] {
match stdio {
StdioResult::Buffer(mut pipe) => {
pipe.close(Subprocess::on_pipe_close)
}
StdioResult::Fd(fd) => fd.close(),
StdioResult::Unavailable => {}
}
}
✷
uv_close is asynchronous: libuv keeps the raw handle pointer until the next loop tick, then calls on_pipe_close, which frees the allocation. But `pipe` is a Box that drops at the end of this match arm libuv is left holding freed memory, and the close callback then frees it a second time. Use-after-free, then double-free.
✷
for stdio in [spawned_stdout, spawned_stderr] {
match stdio {
StdioResult::Buffer(pipe) => {
Box::leak(pipe).close(Subprocess::on_pipe_close)
}
StdioResult::Fd(fd) => fd.close(),
StdioResult::Unavailable => {}
}
}
f0a454376c14 · win-review: js_bun_spawn_bindings.rs leak Box<uv::Pipe> before async uv_close to avoid UAF/double-free in on_pipe_close
Three bugs the adversarial reviewers actually caught. every cited commit carries its review attribution in the subject line. All three compiled; all three looked plausible. The reviewer is a second Claude in its own context window: it gets the diff and nothing else none of the implementer's reasoning, and is told to find the way it's wrong. Code is condensed from the cited commits; same bugs, same fixes.

Working together

  • How does a project start?

    A short discovery call, then a written scope with one clear deliverable, a timeline and a fixed price. You see all of that before anything is agreed.

  • What happens when it is finished?

    It goes live in your environment, documented, with a handover so your team can run it without me. No retainer required to keep it working.

  • Can it run on our own hardware?

    Yes. Private models, access controls and audit logs, with no data leaving your infrastructure. That is a normal request, not an exception.

  • Who actually does the work?

    I do. You talk to the person writing the code, with no account manager or handoffs in between.

  • How do I know the AI-generated parts are sound?

    Everything goes through adversarial review and a green build before it ships. The Method section above shows how that runs.

Get in touch

Let's talk.

Tell me what you need. Every message reaches me directly.

01 03

What brings you here?

Prefer the classic way?

Email meBook 30 min

Or email me directly at eduardd.hv@gmail.com