AI agents · Granada / Remote
An AI agent runs a process end to end: it reads, decides, calls into your systems and knows when to stop. I design and integrate agents for the repetitive processes in your company, with guardrails and human approval at the points where a mistake costs something. Behind every integration sit ten-plus years of building backend systems.
An AI agent is a language model plus three things: tools it can use to act on your systems, a memory of what it has already done, and an explicit criterion for stopping. That last part is what separates a useful agent from a demo — the agent decides how many steps to take, but you decide where its authority ends.
The difference from a chatbot is that an agent does not just answer. It opens the ticket, looks the order up in your ERP, drafts the reply and leaves it waiting for approval. Autonomy is a dial rather than a switch, and for most processes the right setting sits well away from either extreme. Finding it is part of the work.
Sessions with the people who do the work today, to map the real process and its exceptions. Out of that comes the design: which steps the agent executes, what information it needs at each one, and the exact point where a person steps in.
Every action the agent takes is a narrowly scoped function against your systems: email, CRM, ERP, database or internal APIs. With least-privilege access, parameter validation and rate limits, so the blast radius of a mistake is small and known.
Explicit rules for what the agent may not do on its own, approval queues for sensitive actions, and a record of why it made each decision. An agent you cannot audit is an agent that never reaches production.
A suite of real cases — including the odd ones and the ones that went wrong — run automatically on every change of prompt, model or tool. It is the only way to know whether an improvement improved anything.
Deployment on your infrastructure, with step-by-step traces, alerts when the agent gets stuck or goes off-script, and cost per run visible from day one.
Guardrails first, autonomy later. I start from what the agent must not do and how we are going to measure it; the room for judgement widens afterwards, with usage data behind it. I work with commercial models from Claude, OpenAI or Gemini — the choice depends on the cost, latency and quality your case demands — and orchestrate with LangGraph when the flow has branches and state, or with plain code when it does not. The integration lives where your product lives: inside a Rails application, in a separate Python service, or behind an API.
I map the process with your team, measure how much time it consumes today and scope the first agent to the stretch with the best ratio of volume to risk. Output: the design, the success criteria and an estimated cost per run. One to two weeks.
I build the agent against your systems in a test environment and run it in shadow or propose-only mode over real cases. By the end we know what share it handles well, where it fails and whether it is worth continuing. Two to four weeks.
Final integration, guardrails, approval queues, evals in CI and monitoring. The agent goes live with human supervision on the sensitive actions. Three to six weeks, depending on how many systems are involved.
A few weeks of real use show which cases can be fully automated, which will keep going through a person, and which neighbouring process is the next candidate. These timelines are indicative: the critical path is usually integrations and access approvals, not the model.
AI consulting for companies: find out where AI, agents and RAG actually pay off, with a senior engineer. From idea to production system, no hype.
RAG implementation consultant: reliable answers over your documents, with source citations. Real production experience. From pilot to production.
Tell me about your case and I'll tell you honestly whether AI is the right tool — and how I would implement it.