Responsibilities

● 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 coding best practices

● Work closely with customer and internal teams that consist 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 hallucinations

● Knowledge of designing 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 a. Agentic System Orchestration (ASO)

i. 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 workfl ows on Vertex AI.
- LangGraph / LangChain: OSS frameworks for managing stateful agentic fl ows.
- Pydantic: Used for strict data validation and schema defi nition 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.

b. Modern Software Standards i. 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 fl ows.
- Identity & Data Protection: Implementing OAuth 2.0/OIDC fl ows, IAP, and Confi dential 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 workfl ows for long-running AI inferences.
- Identity & Access Management (IAM): Designing fi ne-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 confi guration.
- Cloud Run / GKE:



Primary platforms for deploying secure, containerized applications.
- OpenAPI (Swagger): For defi ning and governing the API contract.
- Cloud Pub/Sub / Cloud Tasks: For managing asynchronous background work.
- Artifact Registry: For managing and signing secure container images.

a. Software Engineering Core:

i. Focus: This is the bedrock of computer science discipline. It is the ability to translate complex business logic into effi cient, 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: Profi ciency in designing logic fl ows 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 fl uency 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 fl ows 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 skilled languages for high-concurrency or enterprise-grade backend systems.
- VS Code / Project IDX / IntelliJ: Standard IDEs for professional 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 verifi ed and stable.

📌 Lead AI Engineer (Australia)
🏢 Nityo Infotech
📍 Australia