New opportunity

SB-1486-AI Engineer Intern

Softobiz · Kochi, India

About this role

Softobiz is seeking five AI Engineering Interns in Kochi for a mentored, hands-on internship contributing to production-grade agentic AI systems. The posting labels the opportunity Full-Time and lists 0–1 years of experience. Interns will work with senior engineers on multi-agent workflows, context architecture and LLM integration, with an opportunity to develop toward a full-time AI Engineer role.

Responsibilities

Help build LangGraph workflows in Python with Pydantic structured output, including stateful, resumable graphs, retries, checkpointing and human-in-the-loop pause/resume points.
Contribute to layered context management, retrieval and indexing, context selectors, token-budgeted prompts, history summarisation and typed schemas that give each agent step relevant context.
Integrate LLM providers such as Anthropic and OpenAI/Azure OpenAI; support prompt engineering, tool calling, vector search, embeddings, code-intelligence techniques and model-routing experiments balancing task, latency and cost.
Help develop evaluation and error-analysis loops, validation and deterministic checks. Make agent decisions observable, auditable and reproducible. Collaborate on deployment, inference and persistence, and participate in design reviews, code reviews and Demo Friday.

Requirements

Final-year students and recent graduates are welcome. Candidates should be pursuing or have recently completed a B.Tech, B.E., M.Tech or MCA in Computer Science or a related field, or have equivalent qualifications. Strong data structures, algorithms, complexity analysis, problem-solving and hands-on Python 3.10+ skills, including async and typing, are essential. Academic or self-directed LLM or agentic AI exposure, analytical debugging, clear communication, collaboration and receptiveness to feedback are valued. Competitive-programming experience is a plus.

Preferred or useful exposure includes LangGraph, context engineering, multi-agent design, LLM SDKs, Pydantic v2, JSON Schema, vector stores such as Qdrant or Azure AI Search, Model Context Protocol, CrewAI, Microsoft Agent Framework, Temporal and vLLM. Relevant AI/ML, agentic-AI or cloud-fundamentals certifications are preferred or considered a plus.

For full details about this role, click “Apply on company site” to view the employer’s original posting.

Skills for this role

PythonData structuresAlgorithmsComplexity analysisProblem-solvingLangGraphPydanticMulti-agent orchestrationContext engineeringPrompt engineeringTool callingStructured outputHuman-in-the-loop workflowsRetrievalVector searchEmbeddingsAnthropic SDKOpenAI SDKAzure OpenAI SDKJSON SchemaQdrantAzure AI SearchModel Context ProtocolCrewAIMicrosoft Agent FrameworkTemporalvLLMModel routingEvaluationError analysis

Checking your profile…

Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.

Understand the role

What matters most

Computer-science fundamentals and Python
The posting calls data structures, algorithms, complexity analysis, problem-solving, and clean Python 3.10+ code with async and typing essential. Prepare to explain implementation choices and their complexity.
Stateful agent workflows
Interns help build LangGraph workflows with Pydantic structured output, including branching, retries, checkpointing, and human-in-the-loop pause/resume. LangGraph experience is good to have, not required.
Precise context for each agent step
The role contributes to retrieval and indexing, context selectors, token-budgeted prompts, history compaction, and typed schemas that provide relevant context to each step.
LLM and retrieval integration
Work includes provider integration, prompt engineering, tool calling, structured output, vector search, embeddings, and experiments that weigh task fit against latency and cost.
Reliable, reviewable contributions
Interns help with evaluation, error analysis, validation, and observable, reproducible agent decisions. They also work with senior and platform engineers and share work in reviews and demos.

Likely challenges to think through

Resuming a workflow safely
A likely design challenge is avoiding repeated or inconsistent actions when retries, checkpoints, and human approval interact. Prepare to walk through a small stateful workflow, including what state is saved and what happens after interruption.
Fitting useful context within a token budget
Selecting less context can reduce cost but omit evidence; including too much can obscure what matters. Prepare to explain how you would select, summarise, and check the context supplied to one agent step.
Balancing speed, cost, and trustworthy output
Model routing may improve latency or cost while changing output quality. Prepare to describe a modest comparison with measurable outcomes, structured-output validation, and error analysis rather than assuming one model is best.

Practice your answers

Technical practice

How would you choose a data structure and algorithm for a context-selection task?

What to coverSuggested practice, not a confirmed interview question: Explain how you would rank or filter candidate context items under a token budget. Compare the time and space complexity of two approaches and describe how you would test edge cases.

How would you use Python typing and async code in an LLM workflow?

What to coverSuggested practice: Describe typed interfaces for agent state, provider calls and tool results, then explain when asynchronous calls could improve throughput. Address exception handling, timeouts and readable Python 3.10+ code.

How would you model a resumable multi-agent workflow?

What to coverSuggested practice: Sketch states and transitions for branching, looping and retries in LangGraph. Explain what must be checkpointed so a paused workflow can resume safely, including after a human-in-the-loop decision.

How would you give each agent step relevant context without exceeding a token budget?

What to coverSuggested practice: Compare layered context, selectors or filters, and summarisation of long histories. Explain how you would preserve important information while checking whether compaction changed the answer.

How would you retrieve useful information from a large codebase?

What to coverSuggested practice: Explain how indexing, embeddings and vector search could help find relevant code, and where code structure or exact matches may also matter. Describe how you would assess retrieval quality before passing results to an agent.

How would you integrate an LLM provider with tool calling?

What to coverSuggested practice: Walk through a provider request, a tool call and the return of a tool result using a clear interface. Discuss how you would handle malformed arguments, provider errors and differences between supported providers.

How would you validate structured agent output?

What to coverSuggested practice: Explain how Pydantic or a JSON Schema contract could define expected fields and types. Distinguish schema validation from deterministic checks that verify whether the content is actually acceptable.

How would you investigate an unreliable agent response?

What to coverSuggested practice: Describe an evaluation and error-analysis loop that captures the input, selected context, tool results and output. Explain how you would classify failures, test a proposed change and make the result reproducible.

How would you compare models for different agent tasks?

What to coverSuggested practice: Propose a small routing experiment using task quality, latency and cost as criteria. Explain the trade-off between a faster, cheaper model and one that performs better on a difficult task.

What state would need to persist when deploying a resumable workflow?

What to coverSuggested practice: Identify workflow state, checkpoints and relevant decision records that must survive a restart. Explain how you would work with platform engineers to test resumption and make decisions observable without assuming a particular deployment stack.

Behavioural practice

Tell me about a difficult bug you investigated systematically.

What to coverSuggested practice, not a confirmed interview question: Use a real example to describe the situation, the evidence you gathered and the steps you took to isolate the cause. State the result and what you would check differently next time.

Tell me about feedback you received on your code or technical approach.

What to coverSuggested practice: Describe the situation, how you evaluated and acted on the feedback, and the resulting change. A class or self-directed project example is appropriate if you have not worked in an engineering team.

Tell me about explaining a technical decision to someone with a different background.

What to coverSuggested practice: Give the situation, what you did to make the explanation clear and how you checked understanding. Describe the result without claiming agreement or success that did not occur.

Tell me about coordinating work with others on a shared technical task.

What to coverSuggested practice: Describe your contribution, how you handled dependencies or differing views, and the outcome. If relevant, use an example involving a review or an interface between components.

Tell me about an experiment that did not work and how you shared what you learned.

What to coverSuggested practice: Explain the goal, what you tried, how you measured or diagnosed the failure, and what you communicated to others. Finish with the result or next step; the posting specifically values sharing failed experiments.

Sharpen your knowledge

Topics to prepare

Data structures and complexity
Required: strong DSA, complexity analysis and problem-solving. As a revision exercise, compare two approaches to selecting the highest-scoring items under a size limit; explain their time and space costs and test edge cases.
Stateful agent workflows
LangGraph is good to have, and the work involves branching, looping, retries, checkpointing and human-in-the-loop pauses. Sketch a small workflow as a state graph, then trace what happens if a step fails or a reviewer pauses and resumes it.
Context engineering
The role covers layered context, retrieval, selectors, token budgets and history compaction. Given a long conversation and several retrieved passages, decide what each agent step should receive, what to summarise, and what to omit; justify those choices against a fixed token budget.
LLM integration and typed contracts
The posting includes provider integration, tool calling, structured output and typed context schemas; SDKs and Pydantic v2 are preferred. Trace a proposed tool call from input schema to validated result, identifying where malformed arguments or output would be rejected.
Evaluation and reproducibility
The work includes error analysis, deterministic checks, and observable, auditable agent decisions. Design a small evaluation table with inputs, expected checks, observed failures and recorded context; explain how it would help distinguish a retrieval failure from an output-validation failure.

Skills to revise

Implement Python 3.10+ solutions
Python 3.10+, typing and async are required. Practise a typed Python solution to a DSA problem, add edge-case tests, explain its complexity, then write a small async variant that handles several independent calls and propagates failures clearly.
Build a resumable LangGraph exercise
As preparation for a good-to-have technology used in the responsibilities, implement a small branching LangGraph workflow with typed state, a retry, checkpointing and a human-in-the-loop pause/resume point. Test that resumed execution retains the intended state.
Construct a bounded context pipeline
As a suggested exercise for the stated context-management work, write a selector that filters retrieved passages and conversation history into a fixed token budget. Add a compaction step for older history and inspect whether the next step still receives the information it needs.
Validate an LLM tool interaction
For the advertised LLM-integration and structured-output work, practise one tool-calling flow using a listed provider SDK, if available, and a Pydantic schema. Test valid output, missing fields and malformed tool arguments; this is practice, not an additional job requirement.
Prototype embedding retrieval
Vector search and embeddings are preferred exposure and appear in the responsibilities. As a preparation exercise, index a small set of passages with embeddings, retrieve candidates for a question, and inspect one relevant and one irrelevant result before passing any text to an agent.
Run an error-analysis loop
The posting calls for evaluation, verification and reproducibility. Create a few fixed workflow cases, record inputs, selected context, outputs and validation results, then classify failures and make one targeted change. Rerun the same cases to check whether it helped.

Your preparation checklist

Prepare Python and DSA examples
The posting requires data structures, algorithms, complexity analysis, and Python 3.10+ with async and typing. Prepare two solved problems with complexity explanations and a short, clean Python code sample you can discuss.
Outline a relevant project walkthrough
The posting welcomes academic or self-directed LLM and agentic-AI exposure. If you have a relevant project, prepare a brief account of its design, your contribution, one failure, and what you changed. Otherwise, outline a small illustrative prototype without presenting it as completed work.
Sketch a resumable agent workflow
As a preparation exercise, draw a LangGraph-style state machine with branching, retries, checkpointing, a human-in-the-loop pause/resume point, and Pydantic structured output. Mark where you would validate outputs; the posting lists this workflow exposure as good to have.
Explain a context and retrieval design
Prepare a one-page proposal showing how retrieval, context selectors, typed schemas, token budgets, and history summarisation would supply relevant context to each agent step. These are responsibilities in the posting, not stated prerequisites.
Plan an evaluation and debugging walkthrough
Draft a small set of test cases, deterministic output checks, and an error log for the illustrative workflow. Be ready to explain how you would reproduce a failure and make agent decisions and context observable.
Prepare questions for the engineering team
Ask how interns work with senior engineers on design and code reviews, how model-routing experiments compare latency and cost, and what interns typically share at Demo Friday. These questions reflect activities named in the posting; do not assume a particular team process beyond it.

Availability last checked: 4 Nov 2026. Status can change after a check; confirm on the employer’s website. Report an issue · Our checking policy

KEEP EXPLORING

Similar AI jobs

Related skills and specializations in India. Matched to this role, not your profile.

Explore more jobs

Finding similar opportunities…