Responsibilities

Lead AI Engineer

- Lead the design, development and implementation of multi-agent AI architectures to address specific business requirements

- Ability to explain the technical design considerations of the solution

- Develop efficient code that is modular and scalable following the coding best practices

- Work closely with customer and internal teams that consists of software engineers, data scientists and domain experts

- Clearly document system designs, algorithms and implementation details

Primary Skills

- Strong programming skills in python (essential), frameworks like PyTorch, TensorFlow

- Good knowledge of GCP services to develop and deploy applications

- Hands on experience working with Vertex AI generative AI services like Agent Builder, Search and Conversational agents

- Knowledge of implementing guardrails for responsible AI and minimizing hallucination

- Knowledge of designing the AI solutions at scale for considerations like performance, cost and accuracy

- Working knowledge of popular Open Source generative AI frameworks like LangChain, LlamaIndex, Ragas, Langraph, Langsmith

- Solid understanding of machine learning, deep learning and Generative AI concepts including agentic patterns, testing and integration experience.

- Testing of code for quality and optimization

Secondary Skills

- User interface design - Gradio, Streamlit, etc.

- Software engineering - DevOPs - Github, CI/CD

- BigQuery, DataFlow, CloudSQL

- Conversational architectures including experience with DialogflowCX or Gemini Enterprise CX

- Agentic System Orchestration (ASO)

- Focus: This discipline builds systems where AI models act as

autonomous agents that can interact with business tools. It moves AI from a passive chatbot into an active "Execution Arm" capable of performing multi-step business tasks.

Ii. Knowledge &

- Skills:

- Agentic Framework Design: Creating supervisor and sub-agent hierarchies for complex task delegation.

- Tool &
- Plugin Engineering: Building secure, descriptive APIs that allow AI "Brains" to use software "Limbs."

- Nondeterministic Logic Management: Handling unpredictable AI outputs and providing fallback mechanisms.

- Chain of Thought (CoT) Engineering: Designing prompts and loops that allow for complex reasoning.

- EvalOps: Implementing systematic evaluation frameworks to measure agent accuracy and safety.

- Semantic Entity Mapping: Bridging unstructured AI data with structured internal systems (e.g., AIG risk ratings).

- Advanced RAG: Building Retrieval Augmented Generation pipelines, including Graph-based RAG.

- Agentic Observability:



Tracing the reasoning steps of an agent for auditing and debugging.

Iii. Tools:

- ADK (Agent Development Kit): The foundational SDK for building agentic workflows on Vertex AI.

- LangGraph / LangChain: OSS frameworks for managing stateful agentic flows.

- Pydantic: Used for strict data validation and schema definition for agent tools.

- Spanner Graph / GQL: For managing complex entity relationships in AI applications.

- FastAPI: The standard tool for building high-performance APIs for agentic tools.

- Vertex AI Extensions: For connecting agents to Google Cloud services and third-party APIs.

- Modern Software Standards

- Focus: Setting the Guardrails for production. This stage applies elite engineering norms and regulatory requirements to ensure code is

defensible, secure, and compliant from day one.

Ii. Knowledge &

- Skills:

- Implementation Frameworks: Applying Clean Architecture and SOLID to ensure decoupled, testable codebases.

- 12-Factor App Discipline: Ensuring applications are stateless, externalized, and natively built for cloud-scale.

- Regulatory &
- Data Privacy: Implementing PII/PHI masking, Cloud DLP integration, and regional compliance (e.g., CPS 230, APPI).

- Sovereign Engineering: Designing for data residency and localized processing within national borders.

- Application Security Mastery: Externalizing secrets, managing JWTs, and implementing complex OAuth 2.0/OIDC flows.

- Identity &

- Data Protection: Implementing OAuth 2.0/OIDC flows, IAP, and Confidential Computing patterns.

- Software Supply Chain Security: Implementing SLSA standards to ensure the provenance of every code artifact.

- Asynchronous Execution: Implementing background workers and non-blocking workflows for long-running AI inferences.

- Identity &

- Access Management (IAM): Designing fine-grained security policies for application components.

- Identity-Aware Proxy (IAP) Design: Protecting applications via identity-based access control.

- PII Data Handling: Applying knowledge of encryption and masking to protect sensitive data.

Iii. Tools:

- Google Cloud Build: The instrument for automated CI/CD pipelines.

- Google Secret Manager: The hammer used to externalize and protect sensitive configuration.

- Cloud Run / GKE:



Primary platforms for deploying secure, containerized applications.

- OpenAPI (Swagger): For defining and governing the API contract.

- Cloud Pub/Sub / Cloud Tasks: For managing asynchronous background work.

- Artifact Registry: For managing and signing secure container images.

- Software Engineering Core:

- Focus: This is the bedrock of computer science discipline. It is the

ability to translate complex business logic into efficient, elegant, and maintainable software. It ensures that regardless of the "domain" (AI, Infra, or Web), the resulting code is of the highest professional standard, optimized for both human readability and machine execution.

Ii. Knowledge &

- Skills:

- Algorithm Design &
- Complexity: Proficiency in designing logic flows and understanding time/space complexity (Big O) to ensure code scales with data.

- Advanced Data Structures: Selecting the right instrument for the job (e.g., understanding when to use a Hash Map vs. a Tree vs. a Graph) to optimize memory and lookup speeds.

- Python Mastery (Mandatory): Deep fluency in Python idioms, including asynchronous programming, decorators, generators, and memory management

- Polyglot OOP Programming: Fluency in at least one other major Object-Oriented language (e.g., Go, Java, or C ) to understand cross-paradigm architectural trade-offs

- Logic Transposition: The ability to take a complex "EA

Notebook" or "Business Whiteboard" and refactor it into clean, modular, and reusable classes and functions.

- Clean Code &
- Refactoring: Applying the "Boy Scout Rule" (leaving code better than you found it) and ensuring expressive, self-documenting naming conventions.

- Functional vs.

OOP Paradigms: Knowing when to apply functional programming concepts (immutability, pure

functions) versus traditional Object-Oriented patterns.

- Mental Modeling: The ability to visualize complex system

states and data flows before a single line of code is written.

Iii. Tools:

- Python: The mandatory primary language for AI/ML and Cloud orchestration.

- Go / Java / .NET/ Typescript: Secondary professional

languages for high-concurrency or enterprise-grade backend systems.

- VS Code / Project IDX / IntelliJ: Standard IDEs for skilled software construction.

- Git: The fundamental tool for version control and collaborative history management.

- Pylint / Ruff / Mypy: Static analysis and type-checking tools to ensure Python code quality.

- PDB / Delve: Advanced debugging tools for deep-dive logic interrogation.

- Pytest / Unittest: Frameworks for ensuring the core logic remains verified and stable.

📌 AI Lead (City of Perth)
🏢 ALOIS UK
📍 City of Perth