Agentic Engineer

Agentic Enginner

Dubai

Production agentic AI systems, LLM orchestration, MCP/A2A tool connectivity, RAG, evaluation, observability, safety and cost optimisation

• Design, build and operate production-grade agentic AI systems that can reason, use tools, maintain state, retrieve knowledge, execute multi-step workflows and escalate safely to humans when required.
• Select and integrate appropriate LLMs and agent frameworks across Azure OpenAI, Anthropic, open models and provider-native agent SDKs, balancing latency, cost, quality, data residency and compliance needs.
• Engineer reliable tool-use patterns including function calling, structured outputs, MCP servers, API wrappers, permissions, retries, timeouts, sandboxing and audit trails.
• Implement retrieval, memory and context-engineering patterns including RAG pipelines, hybrid search, re-ranking, short-term and long-term memory, summarisation and context budgeting.
• Own agent evaluation, safety and observability: automated evals, golden datasets, red-team testing, prompt-injection defences, PII controls, traceability, dashboards and production feedback loops.
• Optimise performance and commercial viability through token budgeting, prompt caching, model routing, batching, cost monitoring and continuous improvement of agent success rates.

Agent Architecture & Design

• Define agent workflows: What are the agent's goals? What tools does it need (APIs, databases, search)? What's the decision loop?
• Choose orchestration framework: LangChain, LlamaIndex, Azure Semantic Kernel, or custom agent loop (depends on complexity)
• Design tool interfaces: What functions can agents call? What parameters? What's the expected response format? (Function calling / structured output)
• Implement error handling: What if a tool fails? Can the agent recover? When should it escalate to human?
• Design multi-turn conversations: Context window management (summarize old turns, drop less relevant context); prevent infinite loops

LLM Selection & Prompting

• Evaluate models for use case: Latency requirements (Claude 3.5 Sonnet is fast for reasoning; GPT-4o for multimodal), cost per 1M tokens, context window (4K vs. 200K)
• Write system prompts: Clear role definition, task boundaries, safety guidelines (e.g., "Never execute user code directly"; "Always verify customer identity")
• Implement few-shot prompting: Provide examples of desired behavior; show edge case handling
• Implement chain-of-thought: Ask agents to reason step-by-step before answering; improves accuracy on complex tasks
• Test prompt robustness: Does it handle jailbreak attempts? Adversarial inputs? Different languages (Arabic for UAE)?

Tool Integration & Function Calling

• Define tool schemas: Functions agents can call (search database, fetch customer data, send email, make payment)
• Implement tool wrappers: Validate inputs (prevent SQL injection, large data fetches), execute safely in sandboxed environment, return structured responses
• Implement guardrails: Rate limit tool calls (prevent denial of service), check permissions (agent can't access customer data it doesn't own), audit logging
• Handle tool failures: Retry logic, fallback tools, error messages that help agent understand what went wrong
• Optimize tool calls: Batch calls if possible (fewer API round-trips), cache results (same question asked multiple times)

Prompt Caching & Cost Optimization

• Implement prompt caching (Azure OpenAI, Claude Prompt Caching): Reuse long context (documents, code) without re-processing; save ~90% of tokens for cached portions
• Batch requests: If processing multiple documents/queries, batch them into single API call (if semantics allow)
• Use cheaper models for certain tasks: GPT-4o Turbo for complex reasoning, GPT-4o Mini for simple classification
• Implement token counting: Estimate costs before running agents; flag agents that are exceeding budget
• Monitor API costs: Track spend by agent, by