Services
Production AI agents built by engineers who have shipped them — not by teams who learned the word last quarter. We map use cases to the agent-vs-pipeline decision honestly, design tool orchestration that survives at 2am, build memory tiers that do not balloon your OpenAI bill, and ship human-in-the-loop checkpoints on every irreversible action. Observability and cost controls are wired in from day one. Feasibility sprints from 9,500 EUR, working MVPs from 40,000 EUR, production retainers from 16,000 EUR per month.
Most agent projects fail because the problem did not need an agent. A deterministic pipeline plus one LLM call would have shipped in three weeks and run for a tenth the cost. We say so in the feasibility sprint. When you do need an agent — multi-step workflows over changing state, tool sequences that cannot be hardcoded, verifiable success criteria — we build them the way they survive production: explicit graphs, validated tool calls, hard token budgets, tiered human-in-the-loop, and observability that captures every step. The agent that runs your refunds queue cannot loop 40 times into your Stripe bill at 3am and discover it on Monday.
We score candidate workflows on the three agent prerequisites — non-deterministic tool order, evolving state, verifiable success — and we explicitly call out the ones where a pipeline plus one LLM call would ship faster and cheaper.
Tool definitions with strict Pydantic schemas, retry and back-off per tool, idempotency keys on writes, and an explicit graph so the control flow is debuggable instead of emergent. LangGraph, Temporal, or Inngest depending on durability needs.
When the workload genuinely benefits from specialist agents (rare), we design supervisor and worker patterns with clear hand-off contracts. When it does not, we save you the complexity and ship a single-agent system that you can actually operate.
Short-term conversation buffer with summarisation, long-term episodic memory in pgvector or Weaviate, semantic RAG for the underlying corpus. Each tier sized explicitly so memory cost stays at 30 to 60 percent of LLM cost, not 300.
Tiered approvals: autonomous for reads, async-revert for medium-risk writes, sync-approval for irreversible actions (email, production, payments). Approval UIs are part of the deliverable — Slack interactive messages, your admin, or a custom inbox.
Per-task token and dollar budgets enforced at the orchestrator. Step-level traces in Langfuse, Helicone, or Arize. Cost alerts wired to PagerDuty, not dashboards you check on Monday. Eval harness running in CI on every prompt change.
Weeks 1–2: use-case mapping, agent-vs-pipeline decision, tool inventory across your existing APIs, ROI model. Output is a written go/no-go with the cheaper alternative scoped if go is no.
Weeks 3–4: orchestrator chosen (LangGraph vs Temporal vs Inngest based on durability), tool schemas in Pydantic, memory tiers sized, checkpoint tiers assigned per tool, ADRs written.
Weeks 5–9: agent built, tool integrations live, human-in-the-loop UI shipped, observability wired, eval harness running in CI, customer-zero deployment behind a feature flag with hard budget caps.
Week 10+: gradual traffic ramp, cost and latency SLOs, runbook for stuck agents and tool outages, your team trained on adding tools and expanding the eval set. We step out when your team is operating it.
Two weeks. Use-case mapping, agent-vs-pipeline decision, tool inventory, ROI model, written architecture proposal. Best when you do not yet know if "agent" is the right word for your problem. 9,500 EUR fixed.
7 to 9 weeks. Working agent, tool integrations, memory tiers, human-in-the-loop checkpoints, observability, eval harness in CI, customer-zero deployment with hard budget caps. 40,000 EUR fixed.
Monthly. Prompt iteration, new tool integrations, eval expansion, cost optimisation, on-call for agent-specific incidents. Best after MVP ships and the agent owns real workflows. From 16,000 EUR/month.
All engagements start with a mutual NDA, IP assignment, and a DPA. Three-month minimum on the production retainer, month-to-month thereafter with 30 days notice.
Native iOS and Android e-signature clients with a Symfony + React CRM for a cross-border law firm — KYC onboarding and a defensible evidence trail for US & EU matters.
Production social platform — App Store + Google Play, live across the US and EU — with geo Radar, encrypted messaging and a virtual economy.
Android + iOS refactor and rebuild for a German last-mile logistics operator — multi-point route planning, real-time driver tracking and in-app invoicing live in the EU.
GDPR-aligned · ISO 27001 ready · SOC 2 Type II in progress · HIPAA-capable · CCPA-acknowledged
We have killed more agent projects than we have shipped. When a pipeline plus one LLM call wins on cost and reliability, we say so — even though it shrinks our scope. The MVPs we do ship survive production.
Our agent leads have run durable workflows on Temporal and Inngest before agents existed. They know what an orphaned task looks like in a queue at 3am, and they design checkpoints accordingly.
Hard token and dollar budgets at the orchestrator from day one. Memory tiers sized to keep cost predictable. Agents that cap themselves before they cap your finance team.
We treat agents as production systems with non-deterministic control flow — not as chatbots that happen to call APIs. The discipline difference is the difference between an agent that runs your refunds queue and one that costs you a Monday-morning incident review.
Default to a single LLM call. Move to an agent only when the task has three properties: it requires multiple tool calls whose order cannot be hardcoded, it operates over state that changes across turns, and the success criterion is verifiable enough that the agent can self-correct. Customer support triage is rarely an agent; ops workflows that touch four internal APIs in a different order each time often are. We refuse agent projects where a deterministic pipeline plus one LLM call would ship in half the time with a quarter of the bugs.
Depends on the workload. LangGraph for stateful agents with branching control flow and human checkpoints — the explicit graph is worth its weight when you debug at 2am. CrewAI or AutoGen when multi-agent collaboration is the actual pattern (rare). OpenAI Assistants when the workload is tightly coupled to OpenAI's tool format and you do not need portability. Temporal or Inngest when the agent is really a durable workflow with LLM steps inside. Vercel AI SDK for Next.js front-ends with simple tool use. We pick on operational fit, not vendor preference.
Three controls. Hard per-task token and dollar budgets at the orchestration layer — the agent terminates with a clear error before it loops 40 times into your OpenAI bill. Step-level tool-call validation through Pydantic so invalid arguments are caught before the API call, not after. Human-in-the-loop checkpoints on irreversible actions (sending email, posting to production, charging a card). Observability through Langfuse, Helicone, or Arize logs every step, every tool call, every token. Cost alerts fire on the orchestrator, not the dashboard you check on Monday.
Memory is three things, not one. Short-term: the current conversation buffer, summarised when it exceeds context budget. Long-term episodic: facts the agent learned about the user or task, stored in a vector store with semantic recall (pgvector or Weaviate). Long-term semantic: the corpus the agent retrieves from, treated as a RAG subsystem. We size each tier explicitly because naively cramming everything into the context window costs five to ten times more per request and degrades quality. Per-agent memory cost is typically 30 to 60 percent of the LLM cost when designed; 300 percent when not.
Tiered checkpoints. Tier 1 (autonomous): read-only actions, no human gate. Tier 2 (async review): a human sees and can revert within a window, but the agent does not block. Tier 3 (sync approval): irreversible actions (sending email, posting to production, charging) wait on human approval before execution. The approval UI is part of the deliverable, not an afterthought — usually a Slack interactive message, a queued action in your existing admin, or a custom approval inbox. Tier assignment is per tool, written down, and changes through PRs not Slack.
Three tiers. Agent feasibility sprint is 9,500 EUR over two weeks: use-case mapping, agent-vs-pipeline decision, tool inventory, ROI model, and a written architecture proposal. Agent MVP is 40,000 EUR over 7 to 9 weeks: working agent, tool integrations, memory, human-in-the-loop checkpoints, observability, and a customer-zero deployment. Production agent retainer starts at 16,000 EUR per month: prompt iteration, new tool integrations, eval expansion, cost optimisation, and on-call. Typical path from kickoff to production is 10 to 14 weeks.
