Robotics Engineer

Position: Guidance & Navigation Engineer

Experience: 1–3 Years

Location: Bengaluru, Karnataka

Employment Type: Full-time

About the Role

We are seeking a highly motivated Guidance and Navigation Engineer to join our autonomy and avionics team. The role involves developing, implementing, and validating state estimation, navigation, and guidance algorithms for autonomous UAVs operating in both GNSS-available and GNSS-denied environments.

The ideal candidate should have a strong foundation in estimation theory, sensor fusion, and navigation algorithms, along with hands-on experience in implementing these algorithms on embedded or real-time systems.

Key Responsibilities

• Design, develop, and optimise navigation and guidance algorithms for UAVs.
• Develop state estimation algorithms using IMU, GNSS, magnetometer, barometer, cameras, LiDAR, radar, and other onboard sensors.
• Design and implement estimation filters such as: EKF, UKF, Point-mass Filter
• Develop sensor fusion algorithms for robust localisation under degraded or denied GNSS conditions.
• Work on inertial navigation, dead reckoning, visual-inertial odometry (VIO), visual odometry (VO), and multi-sensor navigation systems.
• Develop guidance algorithms for waypoint navigation, path following, trajectory generation, and autonomous mission execution.
• Perform simulation, algorithm validation, and performance analysis using MATLAB/Simulink, Python, or C++.
• Analyse flight logs and sensor data to improve navigation accuracy and system robustness.
• Integrate navigation software with autopilots, embedded processors, and avionics systems.
• Support hardware-in-the-loop (HIL), software-in-the-loop (SIL), and field flight testing.
• Work closely with perception, controls, embedded software, and systems engineering teams.

Required Qualifications

• B.E./B.Tech/M.E./M.Tech in Aerospace Engineering, Robotics, Electronics, Electrical Engineering, Computer Science, Mechatronics, or a related discipline.
• 1–3 years of experience in navigation, estimation, robotics, autonomous systems, or UAV development.
• Strong understanding of: Linear Algebra, Probability and Statistics, Estimation Theory, Kinematics, Coordinate Systems, Control Systems,
• Experience developing estimation filters, especially EKF or UKF.
• Good understanding of IMU error modelling and inertial navigation.
• Experience with Camera, IMU Calibration and Synchronisation
• Experience with multi-sensor fusion.
• Strong programming skills in C++ and Python.
• Experience with MATLAB/Simulink for algorithm development and validation.
• Familiarity with Linux development environments.
• Experience with Git version control.

Preferred Skills

• Experience with Visual-Inertial Odometry (VIO), Visual Odometry (VO), or SLAM with loop closure techniques
• Knowledge of factor graph optimisation (GTSAM, Ceres Solver, g2o, etc.).
• Experience with ROS/ROS2.
• Familiarity with PX4 or ArduPilot.
• Experience working with embedded Linux or ARM-based processors.
• Understanding of UAV flight dynamics and autopilot architectures.
• Experience with flight data analysis and debugging.
• Exposure to airborne software development processes and coding standards (e.g., MISRA C++).

Personal Attributes

• Strong analytical and problem-solving skills.
• Ability to work independently on challenging technical problems.
• Good communication and documentation skills.
• Passion for robotics, autonomous systems, and aerospace technologies.
• Willingness to participate in field trials and flight testing.

This role offers the opportunity to work on cutting-edge UAV autonomy technologies from algorithm development through real-world flight validation.

About Company

We are building general-purpose autonomous robots for US construction to tackle rising costs, safety risks, and labour shortages. Our modular, multi-trade platform combines purpose-built hardware with real-time site intelligence to navigate complex environments and execute tasks with precision. Trained in high-fidelity simulation and already deployed on live sites, our robots deliver 5x faster execution, 250%+ margin expansion, and significant cost savings.

About the Role

We are looking for a versatile, hands-on software engineer to join our growing team. You will work across embedded Linux systems, networking stacks, robotic middleware, and cloud-connected services. This role demands strong fundamentals, intellectual curiosity, and the ability to learn quickly — not just familiarity with buzzwords.

On-site, Bengaluru

Responsibilities

• Design and implement robot boot-up sequences and service orchestration to ensure reliable, deterministic system bring-up.
• Configure and manage Linux networking — TCP/IP stack, HTTP, iptables, ARP, DHCP, DNS — for robot-to-cloud and inter-robot communication.
• Own CI/CD pipelines using ArgoCD, GitHub Actions, and containerized workflows to ship software to robots.
• Manage Docker-based deployment and runtime environments on robot and cloud infrastructure.
• Write and maintain system administration tooling and bash scripts for fleet management and diagnostics.
• Collaborate closely with robotics, perception, and application teams to integrate platform capabilities.
• Establish and enforce best practices around Git workflows, branching strategies, and code review.
• Lead and mentor a small platform engineering team — set technical direction, conduct code reviews, and drive execution.

Requirements

All candidates must demonstrate solid, hands-on competency in every item listed below.

• Linux systems programming in C
• File I/O — read, write, seek, memory-mapped files
• Multi-threading — pthreads, mutexes, condition variables, thread safety
• Socket communication — TCP/UDP sockets, select/poll/epoll
• Basic data structures & algorithms — stack, heap, queue, linked list
• General comprehension ability — reading technical manuals, datasheets, and RFCs
• Python scripting
• Bash scripting
• Git — CLI usage, branching, merging, rebasing, conflict resolution
• Standard UML diagrams — flowchart, sequence diagram, deployment diagram
• Windowless text editor — vim, nano, or equivalent

Strong Advantage

• C++ programming — C++17, OOP, templates, STL
• Common network protocols — DHCP, ARP, TCP, UDP, DNS
• Network configuration — routers, switches, VLANs, subnetting
• Server-client application architecture
• P2P vs. centralised communication — DDS vs. MQTT
• Database management — SQL vs. NoSQL, schema design
• Network security — checksums (CRC, MD5, SHA), public-key encryption, digital signatures
• ROS2 framework — pub/sub, services, actions, lifecycle nodes, DDS transport
• CMake build system — targets, find_package, CTest integration
• Docker — Dockerfiles, docker-compose, remote image registries

Must-haves (non-negotiable)

• Strong Linux systems programming in C — multi-threading (pthreads), socket communication (TCP/UDP, epoll), and file I/O
• Hands-on experience with CI/CD pipelines (ArgoCD, GitHub Actions) and Docker-based deployments
• Networking expertise — TCP/IP stack, DHCP, DNS, iptables, inter-device communication
• Proficiency in Python and Bash scripting for fleet management and diagnostics
• ROS2 experience (pub/sub, DDS, lifecycle nodes) is a strong advantage

Position: Computer Vision Engineer

Experience: 2–3 Years

Location: Bengaluru, Karnataka

Employment Type: Full-time

About the Role

We are seeking a highly motivated Computer Vision Engineer to join our autonomy and avionics team. The role involves developing, implementing, and validating computer vision models and algorithms and pipelines for UAVs operating in both GNSS-available and GNSS-denied environments.

The ideal candidate should have a strong foundation in theory of deep learning and machine learning, strong understanding of electromagnetic spectrum, imaging fundamentals, camera principles, and mathematical concepts with hands-on experience in implementing these algorithms on embedded or real-time systems.

Key Responsibilities

• Design, develop, and optimise AI Models
• Make custom CNNs/ modify existing CNNs to suit specific problems at hand
• Handle end-to-end training flow
• Implement end to end inference pipelines on standard PCs as well as on embedded systems
• Understand performance benchmarks and assess the accuracy and inference times
• Implement traditional image processing algorithms
• Factor the code to leverage underlying hardware architecture
• Prune the networks for efficiency
• Integrate the system within the application framework using C++
• Work closely with perception, controls, embedded software, and systems engineering teams.

Required Qualifications

• B.E./B.Tech/M.E./M.Tech in Computer Science and Engineering, Electronics, ECE, Mechatronics, or a related discipline.
• 2–3 years of experience in relevant area
• Strong understanding of: Linear Algebra, Probability and Statistics, AI-ML-DL fundamentals, Image processing, Camera Functioning
• Strong programming skills in C++ and Python.
• Experience with MATLAB for algorithm development and validation.
• Familiarity with Linux development environments.
• Experience with Git version control.

Preferred Skills

• Experience with Camera, IMU Calibration and Synchronisation
• Experience with multi-sensor fusion.
• Experience working with NVIDIA devices
• Experience on FPGA will be an added advantage
• Full understanding of Git functionality
• Exposure to airborne software development processes and coding standards (e.g., MISRA C++).

Personal Attributes

• Strong analytical and problem-solving skills.
• Ability to work independently on challenging technical problems.
• Good communication and documentation skills.
• Passion for solving challenging problems
• Willingness to participate in field trials and flight testing.
• Team player

Hands-on plugin and extension engineering (Ruby on Rails first), and agentic AI implementation. Please apply only if you have worked with Ruby on rails along with redmine, odoo.

Responsibilities

• Design agent-operable surfaces on each tool: typed, secure APIs, Model Context Protocol (MCP) servers, and webhook-driven automation
• Architect and build Redmine plugins in Ruby on Rails, Odoo modules, and GitHub Apps/Actions
• Engineer enhancements to be upgrade-safe across product versions 

Required Qualifications 

• 10+ years in software engineering, business-systems architecture, or platform engineering, with deep SME knowledge of operational tools such as Odoo, Redmine, GitHub, or comparable ERP/ITSM/DevOps platforms 
• Expert-level proficiency in Ruby on Rails, including production experience building or maintaining Redmine plugins or comparable Rails-based extensions 
• Strong command of business processes across delivery, support, and operations
• Practical agentic development experience: MCP, LLM tooling, AI-assisted automation, or agent-orchestrated workflows in production 
• Proven track record building plugins, modules, and extensions that survive product version upgrades, with disciplined API and integration design 

About Naicos

Naicos, a fast-paced startup, builds AI-native products for algorithmic commerce: the future of how e-commerce runs. Our first products are already live with paying customers, and we are shipping new ones continuously.

Your Role

You will drive the research behind our imaging products, finding approaches to hard, unsolved problems in product and apparel imagery that work at production scale. You will run the experiments, prove what is viable, and hand a working approach to the engineering team.

Who We Are Looking For

•     Total experience: 3 years or more, with a strong research orientation

•     Deep learning frameworks in Python: PyTorch or TensorFlow

•     Image processing in Python: OpenCV, Pillow, scikit-image

•     Working knowledge of diffusion and other image generation models

We are looking for a strong research or research-student profile: someone who investigates, experiments and proves an approach, working closely with the AI Architect. Someone who is driven to build solutions, not just desk research.

AI Skills and Experience

•     Computer vision: classical CV alongside deep learning.

•     Segmentation, image-to-image translation, geometry and lighting; 

•     Generative imaging: diffusion models, conditioning and control, fine-tuning and LoRA,

•     Reads academic papers, judges what is reproducible, and turns one into a working prototype in days

Good to have

•     3D and rendering; published research or open-source contributions; model optimisation for inference cost

Research and innovative problem solving

•     Comfortable where there is no known answer, and defines the approach yourself

•     Solves problems inventively rather than reaching for the biggest model; many results come from classical image processing, fitment and geometric transformation

Other Relevant Skills and Experience

•     Designs experiments: baselines, measurable success criteria, honest reporting of negative results

•     Explains findings to a non-research audience and guides engineers to production

•     Git and reproducible experiment tracking (Weights & Biases, MLflow or similar)

Educational Qualification

•     BE / B.Tech / ME / M.Tech in Computer Science

•     BE / B.Tech / ME / M.Tech in any discipline with proven Computer Vision coursework or work

•     MSc / MS in Computer Science, Maths, Statistics or Computer Vision

•     PhD in Computer Vision or Machine Learning: an advantage, not a requirement

•     Reputed Tier 1 university preferred

About us

MyRico builds personal AI agents for enterprise, the copilots and digital employees that make humans more productive. The MyRico agents sit at the intersection of enterprise memory, high-end security, and an ever-expanding set of capabilities. We're a small team shipping fast, and the product is live with real customers today.

The role

Full-time · Bangalore

You'll own the systems that make an autonomous agent trustworthy in production. This is not just prompt engineering, and it's not model training - it's that and all the engineering layers in between: model steering, memory architecture, orchestration design, latency optimization, deterministic vs non-deterministic systems tradeoff, deployment, and operator tooling.

Concretely, the kind of work you'd have done here last week would include enhancing agent memory systems, runtime and scheduling reliability and predictability, adding new capability and tools to deployed agents, operator tools, live system debugging and benchmarking various models for price, latency and quality. And that is just last week. We are a small nimble startup rapidly working to address customer needs in this growing space, so things change rapidly.

What we're looking for

• More than 7 years of software engineering, with real production ownership of distributed or stateful systems - you've been paged for something you built and made it not happen again.
• Strong understanding of LLM based native app building, combining classic and model driven applications to get the best of both. You've built on LLMs beyond demos: agent frameworks, tool use, context management, eval fixtures, and you know why "it worked in the transcript" isn't evidence.
• Python and shell in production settings; comfortable in TypeScript/Node. You write boring, testable code and prefer the standard library to a new dependency.
• Systems taste: append-only logs, idempotent reconciliation, fold-the-events state machines, and read-only debugging surfaces feel like home.
• Evidence discipline: tests before features, claims backed by quoted observations, decisions written down.

Nice to have

• Experience running the combination of multi-tenant and single-tenant / on-prem-style fleets with ability to handle per-customer isolation, upgrade paths, migration compatibility in both setups.
• Security instincts for products that touch highly sensitive data and systems, including things like executives' email, calendars, and messages: least privilege, loopback-only services, secrets that never hit a log.
• You already orchestrate AI coding agents in your own workflow and have opinions about where they break.

How we work

Small team, high trust, written decisions. Designs get adversarial review before code; PRs get automated review driven to zero open findings; features aren't done until verified on a live system. AI agents do a large share of the implementation, your leverage is judgment: framing the problem, freezing the right design, and knowing when the machine is wrong.

Core Responsibilities

Operational Tools Architecture & Feature Planning 

• Own the feature roadmap for operational tools — Odoo, Redmine, GitHub, and adjacent systems — from business-process discovery through design, planning, and phased delivery 
• Serve as the subject-matter expert on how business processes (deal onboarding, delivery, support, finance, engineering operations) map onto tool capabilities, and where the gaps are 
• Design cross-tool workflows and integrations so that work items, code, and business records flow between systems as one coherent operational fabric 

Agentic Implementation & Modernization 

• Design agent-operable surfaces on each tool: typed, secure APIs, Model Context Protocol (MCP) servers, and webhook-driven automation that let AI agents read, create, and resolve operational work safely 
• Lead incremental modernization of legacy tool deployments — upgrading versions, retiring brittle customizations, and replacing manual processes with agentic workflows without disrupting live operations 
• Optimize agentic loops that operate on the tools for cost, speed, and integrity, with guardrails, audit trails, and human-in-the-loop checkpoints where they matter 

Plugin & Extension Engineering 

• Architect and build Redmine plugins in Ruby on Rails, Odoo modules, and GitHub Apps/Actions that extend the products cleanly rather than forking them 
• Engineer enhancements to be upgrade-safe across product versions — tracking upstream releases, isolating customizations behind stable interfaces, and planning migration paths 
• Prioritize contract-first API design between human intent, agent execution, and the underlying tools 

Governance & Quality Control 

• Act as the architectural reviewer for changes to Central tooling, including AI-generated pull requests and agent-authored configuration 
• Mandate testing and characterization coverage around customizations so upgrades and agentic changes land deterministically 
• Establish operational standards — access, data integrity, observability — for agents acting inside business-critical systems 

Required Qualifications 

• 10+ years in software engineering, business-systems architecture, or platform engineering, with deep SME knowledge of operational tools such as Odoo, Redmine, GitHub, or comparable ERP/ITSM/DevOps platforms 
• Expert-level proficiency in Ruby on Rails, including production experience building or maintaining Redmine plugins or comparable Rails-based extensions 
• Strong command of business processes across delivery, support, and operations — able to translate how a business runs into how a tool should behave 
• Practical agentic development experience: MCP, LLM tooling, AI-assisted automation, or agent-orchestrated workflows in production 
• Proven track record building plugins, modules, and extensions that survive product version upgrades, with disciplined API and integration design 
• Commitment to clean, tested, production-grade systems — including when the author of the code is an agent 

Preferred Qualifications 

• Python and Odoo module development experience; PostgreSQL fluency 
• Experience modernizing or migrating legacy tool deployments across major versions 
• Background in SaaS transformation, scale-up, or PE-backed environments 

AuxoAI is hiring a Senior Applied Scientist to design and deploy production-grade AI agents capable of structured reasoning, planning, and decision-making.

This role focuses on building reasoning and decision systems using planning algorithms, search methods, and optimization techniques, rather than chatbot or RAG-style application development. The ideal candidate will design intelligent agent architectures that combine LLM-based reasoning with classical planning, search algorithms, and optimization techniques, operating reliably in real-world environments with constraints around latency, cost, uncertainty, and limited context windows.

You will work on advanced AI systems that power autonomous workflows, decision engines, and tool-driven agent ecosystems.

You will also work on problems where existing architectures may not be sufficient, and will be expected to experiment with new approaches that combine machine learning, graph algorithms, and classical AI techniques to build reliable, production-grade systems.

Location - Mumbai/Bangalore/Hyderabad/Gurgaon (Hybrid - 3 Days a week in Office)

Responsibilities:

• Design and architect modular AI agent frameworks incorporating skill decomposition, tool orchestration, and persistent state tracking.
• Implement planning and search algorithms such as Monte Carlo Tree Search (MCTS), beam search, A search, heuristic search, and graph-based planning approaches* to support complex decision-making tasks.
• Develop decision-making loops that balance trade-offs between exploration vs. exploitation, cost vs. accuracy, and latency vs. reasoning depth.
• Build structured memory systems including episodic memory stores, semantic memory layers, and vector-based memory with optimized retrieval strategies.
• Design tool-calling architectures with strong execution validation, retry mechanisms, and failure recovery strategies.
• Develop evaluation frameworks to measure agent performance using task success metrics, rollout simulations, and multi-sample validation approaches.
• Improve agent performance through techniques such as distillation, synthetic trajectory generation, prompt compression, and context pruning.
• Deliver production-ready agent systems that meet operational requirements around reliability, cost efficiency, throughput, and observability.

Requirements

• 3-10 years of experience building machine learning or AI systems in production environments.
• Strong experience implementing search or planning algorithms beyond basic use cases, including tree search or heuristic-based planning approaches.
• Hands-on experience with Monte Carlo Tree Search (MCTS) or related decision-making frameworks.
• Strong understanding of state-space representations, heuristic design, and decision boundary trade-offs.
• Experience building or extensively customizing agent frameworks for real-world applications.
• Hands-on experience designing tool-use or function-calling architectures under practical system constraints.
• Strong Python engineering skills with a focus on scalable and reliable system design.
• 
  

Candidates whose primary experience is limited to RAG pipelines, prompt engineering, or chatbot frameworks without deeper algorithmic or systems work may not be a fit for this role.

Nice to Have:

• Experience with reinforcement learning techniques such as policy gradients, value estimation, or reward modeling.
• Experience building multi-agent or collaborative agent systems.
• Experience designing evaluation frameworks for agent robustness and reliability.
• Experience optimizing LLM inference pipelines for latency, throughput, and cost efficiency.
• Familiarity with distributed task orchestration systems and large-scale AI workflow management.