NemoAI

Cut your feature delivery time in half. Nemo AI integrates with your existing tools and turns business requirements into ready-to-review pull requests, so your team can focus on high-impact work.

Comment

Inspiration

A recent Google study found that developers spend nearly 65% of their time on mundane, unproductive and low-value tasks that can be automated. With Nemo AI, developers are empowered to spend 50% more of their time towards high-value initiatives such as designing system architectures, driving innovation, and developing strategies to solve complex problems.

What is Nemo AI ?

Nemo AI is an autonomous agent that turns Jira stories into ready-to-review pull requests — automatically. The product owner defines the business requirements in the Jira story, which Nemo AI then interprets and understands to analyze the existing codebase and generate a first draft of the solution as a GitHub pull request. Nemo works seamlessly with the tools your team already uses — including Jira, Confluence, GitHub, and AWS — making it easy to adopt and integrate into your existing development workflow.

Nemo AI – Use Cases

Nemo AI acts as an intelligent assistant across both engineering and data teams, automating time-consuming tasks so your team can focus on higher-value work.

The First Draft

Nemo AI serves as an autonomous software developer that turns Jira stories into ready-to-review pull requests. When a story moves to “In Progress”, Nemo:

  • Reads the Jira ticket and understands the business requirements.
  • Analyzes your GitHub codebase and pulls in relevant context from Confluence, internal wikis, and MCP servers.
  • Uses specialized AI agents to collaboratively plan, write, and peer-review code.
  • Opens a pull request with code changes, documentation, and diagrams.
  • Keeps developers in the loop to review, edit, and merge the PR.

This process cuts feature delivery time in half while maintaining developer oversight and code quality.

Nemo AI First Draft

Nemo’s Unpaid Intern

Nemo AI also functions as a data analyst intern that delivers fast, accurate business insights without requiring SQL or Python skills.

Simply:

  • Write a Jira ticket describing the questions you want answered.
  • Upload your raw data (like CSVs) to your GitHub repo.
  • Nemo reads your request, understands your goals, writes and executes code using AgentCore Code Interpreter, analyzes the data, applies business logic, and figures out how to get the answers.
  • It compiles a polished PDF report—ready to be presented to business stakeholders—along with the underlying code, and creates a GitHub pull request for review.

This lets anyone on your team quickly get data-driven answers and visualizations — saving hours or even days.

Nemo AI Unpaid Intern

How we built it

Nemo is built using a serverless, event-driven architecture, ensuring a cost-effective, scalable, and loosely coupled system.

  • Jira Ingestion: When a Jira story moves to the “In Progress” stage, a webhook triggers a POST request to an ingestion Lambda function. This Lambda processes the incoming data and writes it to a DynamoDB
  • Task Routing and Queueing: Based on the task type, the ingestion Lambda routes requests either to an SQS queue for short-running tasks or triggers an ECS Fargate task for long-running tasks.
  • Core Agent Processing: Two core agents manage task execution based on workload:
    • A Lambda function consumes tasks from the SQS queue, following a producer-consumer architecture to efficiently process short-running tasks.
    • An ECS Fargate-based Core Agent handles longer-running tasks, ideal for more complex use cases.
  • Code Execution with AgentCore Code Interpreter: For data analytics and report generation usecase, Nemo uses the AgentCore Code Interpreter to write and execute Python code securely within a sandbox environment.
  • Integration with External Systems: The Core Agents clone repositories and create pull requests on GitHub. Nemo AI also connect to MCP servers to fetch real-time documentation and AWS best practices.
  • Observability and Monitoring: We use Amazon Bedrock AgentCore Observability to continuously monitor the performance and health of the entire system.

Nemo AI Architecture Diagram

This architecture enables Nemo AI to autonomously transform Jira stories into code, run data analysis, generate reports, and create pull requests—all while maintaining high availability, security, and extensibility.

Nemo's Multi Agent Architecture

  • Nemo AI employs a Multi-Agent Architecture featuring specialized agents, including:
    • Software Engineer
    • Security Agent
    • Coding Standards Agent
    • System Design Agent
    • Data Structure and Algorithm Agent
    • Scoring Agent (which evaluates code against the given business requirements)

This multi-agent setup enables various AI components to collaborate, review, and improve the code continuously—mimicking the way a team of human developers work together to deliver high-quality solutions.

Nemo AI Multi Agent Architecture

Accomplishments that we're proud of

  • Nemo AI helps teams in two big ways: cutting down feature delivery time by turning Jira stories into ready-to-review pull requests (The First Draft), and creating clear, easy-to-understand data reports from business questions (Nemo’s Unpaid Intern).
  • By using MCP servers like Context7 and AWS Knowledge MCP, Nemo stays updated with the latest software libraries and AWS best practices. This helps avoid mistakes from old or outdated information.
  • We use AgentCore Observability to keep a close eye on how Nemo’s multiple AI agents are performing. It helps us find and fix problems quickly so everything runs smoothly.

What we learned

We learned how to design an end-to-end workflow and platform where Agentic AI is the core—not just an add-on feature. This involved building the entire system around AI agents, engineering the product, and maintaining a developer-in-the-loop approach to ensure quality and control.

AWS services used

  • Amazon Bedrock LLMs: Foundation models like Claude Sonnet 4.0, Haiku 4.5 and Amazon Nova Pro for multi specialized AI agents
  • AWS Lambda: Executes short-running tasks and processes Jira webhook events in an event-driven, serverless environment.
  • Amazon ECS Fargate: Handles longer-running and more complex Jira stories
  • Amazon SQS: Queue for producer-consumer architecture and de-coupling.
  • Strands SDK: Implement and orchestrate its multi-agent workflow, connect to MCP server, use tools, and OpenTelemetry integration.
  • Amazon DynamoDB: Stores Jira story data and task metadata
  • Amazon Bedrock AgentCore Code Interpreter: Enables Nemo to securely write and execute Python code within sandboxed environments — analyze files, generate and run code, and produce reports
  • Amazon Bedrock AgentCore Observability: helps you trace, debug, and monitor agent and detailed visualizations of each step in the agent workflow
  • Amazon CloudWatch & X-Ray: Observability through monitoring, logging, and tracing
  • Amazon S3: Stores logs, artifacts, and reports for auditing, monitoring, and troubleshooting purposes.

Strands SDK Integration

  • Strands SDK
    Nemo AI leverages the Strands SDK to orchestrate its multi-agent workflow, enabling collaboration between specialized agents such as the Planner Agent, Software Engineer, Feedback Agents, Jira Story Scoring Agent and Documentation Agent.
  • Strands Tools
    Strands tools to autonomously perform operations across the codebase, including:
    • edit_file – Modify existing source code files
    • create_file – Generate new code, documentation, or configuration files
    • search_keyword – Search the repository to gather relevant context before making code changes
    • run_shell_command – Execute shell commands
  • MCP Server Connectivity
    Through the Strands SDK, Nemo connects with MCP (Model Context Protocol) servers such as Context7 and AWS Knowledge MCP to access real-time documentation, best practices, and contextual insights , helping the agents avoid hallucinations, prevent outdated code generation.
  • OpenTelemetry for Observability All agent actions and tool executions emit OpenTelemetry traces and metrics to Amazon Bedrock AgentCore Observability, for end-to-end visibility through traces and sessions.

Built With

Share this project:

Updates