Galvani is a small engineering studio in Prague with two halves that belong together. We design, refactor, and scale complex systems, and build the harnesses, gateways, and defenses that make language models safe to run in production.
Thirty years of services that carry real traffic: message-driven pipelines, APIs, Kubernetes, observability, and delivery from the domain model to the operations dashboard.
Message-driven and asynchronous pipelines over AMQP and other queues, APIs from REST to GraphQL and JSON-LD, caching and search layers, horizontal scaling on container platforms. Proven on a high-traffic content-moderation and discussion platform and on marketing automation at scale.
Our deepest stack. Symfony and API Platform backends, Doctrine data models, and more than seven years inside the Mautic ecosystem as solution architect and plugin author. We know where these frameworks break under load because we have been the ones on call.
Full-stack delivery in the TypeScript ecosystem: Nuxt and Vue, React, Svelte, Express, and monorepos. Server-rendered where it pays, and honest about hydration, caching and the edge cases that show up only in production.
CI/CD pipelines with test suites and coverage gates, Kubernetes and supervisord, reverse proxies and network isolation. Metrics and dashboards in Grafana, error tracking with Sentry, structured logging, retention policies and cost auditing. Built to be operated, not merely deployed.
PostgreSQL and MySQL as the system of record, Redis for caching and coordination, Elasticsearch for search, SQLite with vector extensions where a single node is the right answer. Schema design, migrations and the query plans behind the p95.
Domain model, API, data layer, frontend, CI/CD and operations, as one piece of work. A decade in architect, solution-designer and CTO roles: technology selection, standards, hiring and mentoring, and the judgement to keep scope small and ship it whole.
Client engagements in this half include a high-traffic content-moderation and discussion platform, a social-feed aggregator, and marketing-automation integrations at scale. Names on request.
What has to hold around a language model when it is wrong, slow, or asked to do something it should not: agent harnesses, inference gateways, loops and queues, retrieval, prompt-injection defense, evaluation.
The board an agent works from is a state machine it cannot wander out of: legal transitions only, atomic claims under a lease, and a verification contract the gated party does not get to write. Roles are defined once and built for whichever runtime runs them.
Unattended runs that survive the night. Message-driven pipelines with retry caps, quota parking that reschedules instead of burning retries, crash-safe redelivery, and success inferred from state rather than parsed from output.
One OpenAI-compatible endpoint over self-hosted engines and cloud providers. It holds the credentials so no application does, loads and evicts models by memory pressure, and refuses loudly instead of silently substituting a different model.
Ingestion, chunking and embedding pipelines feeding hybrid search, lexical and vector with recency weighting, over real corpora. Knowledge bases that agents consult before they re-derive what a previous run already paid for.
A proxy in front of the model and its tools. Every input is deobfuscated and scored deterministically; a model may raise suspicion but can never clear it. Output is watched for persona drift and disclosure, and tool calls are gated to what the role is allowed to do.
Candidate models scored by replaying your own sessions, not a public benchmark. Usage and cost audited per client and per run. Metrics, error tracking and structured logs from the first deployment, because a system is built to be operated, not merely shipped.
Production LLM features we have shipped for clients include a provider-agnostic model adapter, vision-based image moderation, localized prompt templates, per-tenant rate limiting and token-usage auditing, in a charitable fundraising product. Ask and we will talk about what can be shared.
Some are public, some are being prepared for release, and some stay internal. Every one of them runs. All projects
An AI-first kanban over MCP: an augmenting proxy over any backend, a fixed flow agents cannot wander out of, and every rule set from the session.
Prompt-injection defense for agents: an evaluation rig, a red-team arena, and a live screen in front of tool calls.
A self-hosted, OpenAI-compatible inference gateway over local engines (vLLM, llama.cpp, TabbyAPI), an image worker and cloud providers.
Narrow, budgeted MCP servers that connect agents to the systems around them.
An agent platform that continues work instead of restarting it: personas written and tested for the model that runs them, permissions generated per role.
A modular personal assistant: one MCP server, modules behind a typed contract, a core that owns persona, memory and consent.
A knowledge base built for AI consumers, with a gate that refuses what it cannot trust and measured notes on what each model is good at.
Speaker-labelled transcripts and digests from meetings, fully on our own hardware.
One local mirror of GitLab merge requests and Jira tickets for every agent: tracked on demand, whitelisted, with a cursored change feed and a scanner at the door.
Hands-on engineering for every stage of your system's lifecycle — from initial architecture through long-term maintenance.
We design backend systems that scale with your business. Domain modeling, service boundaries, data flow, caching strategies, and infrastructure planning — all documented and ready for implementation. Whether you're starting from scratch or restructuring an existing monolith, we deliver architectures that your team can maintain for years.
Clean, tested PHP code built on Symfony, Doctrine, and API Platform. We build internal tools, REST APIs, third-party integrations, background processing pipelines, and admin dashboards. Every feature ships with tests, documentation, and CI/CD integration. We also prepare codebases for AI-assisted development — structured project specs, coding rules, and agent configurations so your team can use tools like Claude Code, Codex and OpenCode effectively.
Legacy systems hold businesses back. We modernize codebases incrementally where that pays — upgrading PHP versions, migrating from legacy frameworks to Symfony, extracting services from monoliths, replacing outdated patterns with current practice — and we say so plainly when the old code is not worth keeping and a rewrite is the cheaper path. Either way, no downtime.
A thorough review of your codebase, infrastructure, and development practices. We assess security vulnerabilities, performance bottlenecks, architectural debt, and operational risks. This includes API stress testing and load testing — we simulate real-world traffic patterns to find breaking points, slow endpoints, and concurrency issues before your users do. You receive a prioritized report with concrete recommendations and effort estimates — not vague suggestions.
When time is critical. A focused 48-hour engagement for urgent technical problems: production incidents, critical bug fixes, blocked deployments, or time-sensitive features. We assess the situation, propose a plan, and execute — with direct communication throughout.
Production systems need visibility. We set up logging, metrics, alerting, and health checks using tools like Grafana and Sentry. Know when something breaks before your users do — and have the data to fix it fast.
We don't just talk about AI — we use it every day. Claude Code, Codex and OpenCode are part of our workflow for code generation, refactoring, and review. We also prepare your codebase so AI tools actually work well with it: project specifications, architectural decision records, coding standards, and agent rule files (CLAUDE.md, AGENTS.md) that give AI the context it needs.
A transparent, structured process from first conversation to delivery.
We start with a technical conversation to understand your system, constraints, and goals. No sales pitch — just an honest assessment of what's needed.
You receive a clear scope, timeline, and fixed price. We define deliverables upfront so there are no surprises. If the project isn't a good fit, we'll tell you.
We work in short iterations with regular check-ins, using AI-assisted development to move fast without cutting corners. You have full visibility into progress through shared repositories, CI pipelines, and direct communication.
Every engagement ends with documented code, knowledge transfer, and a clear path forward. Your team can maintain and extend everything we build.
Galvani is a small engineering studio in Prague with two halves that belong together: production systems, and the machinery around language models. Thirty years of services that carry real traffic — message-driven pipelines, APIs, Kubernetes, observability — and more than seven years inside the Mautic ecosystem as solution architect and plugin author.
Every project is led directly by the founder. No account managers, no handoffs to junior developers. When you work with Galvani, you get senior-level engineering from the first call to the final commit. We've helped startups ship their first production systems and established companies untangle years of technical debt.
We're early adopters of AI-assisted engineering. We use tools like Claude Code, Codex and OpenCode daily in production work — not as a gimmick, but as a genuine force multiplier. We know how to set up codebases, write specifications, and configure agent rules so that AI tools produce code that's actually production-ready. If you're looking to integrate AI into your development workflow, we can show you how it's done right.
We believe in honest communication, clean code, and building systems that last. If a project doesn't need us, we'll say so.
Tell us about your project. We will follow up to discuss the best next steps.
We use Google Analytics to count visits. Nothing else is stored.