IBM

IBM (International Business Machines Corporation), founded in 1911, is a global leader in technology and consulting. With headquarters in Armonk, New York, IBM has a rich history of pioneering advancements in computing and information technology, continually transforming industries with its innovative solutions.

General
CompanyIBM
Founded1911
Repositoryhttps://github.com/IBM

Start building with IBM's products

IBM offers a wide range of innovative products and services that drive digital transformation for businesses of all sizes. From cloud computing and AI to quantum computing and blockchain, IBM's technologies empower developers and organizations to create and deploy powerful applications. Explore the possibilities with IBM's solutions and see what you can create during lablab.ai hackathons.

watsonx.ai

This is an enterprise AI studio that supports the entire AI lifecycle, allowing users to train, validate, tune, and deploy AI models. It includes tools for generative AI, machine learning, and foundation models like IBM Granite and third-party models from Hugging Face and Meta’s Llama 3. Watsonx.ai also offers capabilities such as the Prompt Lab for prompt engineering, Tuning Studio for model adaptation, and a Flows engine for seamless AI deployment.

watsonx.data

This component provides a robust data store built on an open lake house architecture, supporting both on-premises and multi-cloud environments. It facilitates data engineering, data virtualization, and cost optimization for data warehouses, allowing businesses to modernize their data lakes and streamline data pipelines.

watsonx.governance

A toolkit for AI governance, ensuring transparency, accountability, and ethical AI practices throughout the AI model lifecycle. It helps manage risks, monitor model performance, and ensure compliance with regulatory standards, making AI deployments more responsible and explainable.

  • watsonx Assistant: A conversational AI application for creating chatbots and virtual agents, enhancing customer service with natural language processing.

  • watsonx Orchestrate: An automation solution that uses AI to streamline workflows and automate repetitive tasks across various business domains like HR, sales, and procurement.

  • watsonx Code Assistant: A tool to aid developers by generating code based on natural language inputs, improving productivity and reducing coding complexity.

Granite Models

Granite is IBM's flagship series of LLM foundation models based on decoder-only transformer architecture. Granite language models are trained on trusted enterprise data spanning internet, academic, code, legal and finance.

👉 Try Granite on watsonx.ai

AI Models:

  • Granite 13b chat

  • Granite 13b instruct

  • Granite multilingual

  • Granite Japanese

Embedding Models:

The slate.125m.english.rtrvr and slate.30m.english.rtrvr models are bi-encoder sentence transformers that generate embeddings for various inputs like queries, passages, or documents. Both models are trained to maximize the cosine similarity between pairs of texts (e.g., a query and a passage), producing sentence embeddings that can be compared using cosine similarity.

IBM AI Technologies top builders

Explore the top contributors showcasing the highest number of IBM AI Technologies app submissions within our community.

IBM AI Technologies Hackathon projects

Discover innovative solutions crafted with IBM AI Technologies, developed by our community members during our engaging hackathons.

AnticipatedD/G4LA13_Gala4_Localizing_Code-Graph

AnticipatedD/G4LA13_Gala4_Localizing_Code-Graph

AnticipatedD/G4LA13_Gala4_Localizing_Code-Graph is a resilient Band Agentic Mesh designed for the Pocketful track. It demonstrates how autonomous agents can collaborate to build a four‑stage wallet and payments service with auditability and reproducibility. The factory runs three agent seats — Architect, Builder, and Reviewer — each with a clear mandate. The Architect inspects requests and produces ordered plans with acceptance criteria. The Builder implements endpoints stage by stage, containerizing services and enforcing balances, validation, and conservation of funds. The Reviewer runs harness tests, validates outputs, and rejects failures with clear logs. Recovery is built in: failures trigger mandate updates and retries until all tests pass. - Stage‑1 establishes authentication, balances, and payments. - Stage‑2 integrates a UI layer with Playwright tests. - Stage‑3 adds time‑aware balances, statements, and operator corrections. - Stage‑4 completes the system with refunds and correction batches. Technologies include Python, Docker, Band SDK, Band Desktop, Band Agent API, Band WebSocket API, Playwright, and GitHub Actions. This structured progression shows originality, resilience, and research‑grade ambition. 🛠 Technologies Used (Expanded) - Python 3.12 Core language for backend service implementation. - Docker Containerizes each stage (stage-1 through stage-4) for reproducibility. - Band SDK Connects agents to Band infrastructure. Provides adapters. - Band Desktop (formerly Jam). The coordination surface where Architect, Builder, and Reviewer agents collaborate. - Band Agent API (/api/v1/agent). Used by agents to validate identity, recruit peers, join chats, send messages, and post events. - Band WebSocket API (Phoenix Channels). - Playwright Automates browser tests for Stage‑2 UI integration. - GitHub Actions CI/CD pipeline for automated builds and harness runs.

Speech To Indian Sign Language

Speech To Indian Sign Language

Project Overview The Speech to Indian Sign Language (ISL) application is an innovative accessibility solution designed to bridge the communication gap between the hearing and the deaf or hard-of-hearing communities. By leveraging cutting-edge speech recognition and AI technologies, this platform instantly translates spoken dialogue into accurate Indian Sign Language representations, ensuring real-time, inclusive, and barrier-free interaction. The Problem Traditional communication barriers isolate millions of individuals who rely on sign language, particularly Indian Sign Language (ISL). Standard speech-to-text tools do not fully serve users who process information visually through sign language. There is a critical need for seamless, technology-driven solutions that convert spoken words into visual ISL output instantly, fostering equity in education, workplaces, and daily social interactions. How It Works & Key Features Real-Time Speech Processing: Utilizes state-of-the-art audio transcription models (such as AssemblyAI) to accurately capture and process spoken input in real-time. AI-Driven Translation: Converts transcribed text into corresponding Indian Sign Language structures and visual formats. User-Centric Design: Built with a clean, intuitive interface that makes accessibility tools effortless to operate for anyone, anywhere. Tech Stack Frontend/Backend: Python, Django, HTML, CSS, JavaScript, Bootstrap AI & Integration: Advanced Speech Recognition APIs & Translation Frameworks Impact & Future Vision This project aims to democratize access to communication, empowering deaf individuals to interact effortlessly in public spaces, educational institutions, and professional environments. Future iterations will focus on expanding vocabulary depth, refining real-time avatar animation accuracy, and scaling deployment for broader community reach.

ErrLens

ErrLens

The pipeline is a single async generator (backend/app/pipeline.py). Each step emits an event, and the last one carries the full result. parse: Detects the language, the exception type and message, and all frames (innermost first), and separates user code from library code. Handles chained exceptions and warns about minified traces. resolve_paths: Resolves the ref to a commit SHA, fetches the repository tree and maps absolute trace paths (/home/deploy/app/user.py) to repository paths (app/user.py) by longest suffix match. fetch_context: Fetches ±20-line snippets for the first 3 user frames. If the source line in the trace does not match the repository, it warns and lowers the confidence. blame: Blames the lines around each error line. It then runs a related-commit search: if the error lines have not changed since then, it scores the patches of later commits in the same language against the identifiers and string literals on the error lines (for example '%Y-%m-%d'). This finds the cause when the line the trace points to is not the one that changed. analyze: Calls the LLM with a forced tool call. The output is validated in two layers: first the schema, then the semantics (the file and line range must be inside the shown snippet, the diff must build, and the code must pass a Python/JS syntax check). On failure, the error goes back to the model and it gets one retry. If it still fails, the result is returned without a fix. build_fix: Turns the edit into a unified diff with difflib; the LLM never writes the diff itself. The confidence score is 0.6 × LLM confidence + 0.4 × average of signals. The signals are: user frame resolved, change within the last 14 days, error type matches the line, fix validated, trace lines match the commit. done: Saves the result to SQLite. The cache key is a hash of the normalized trace, the repository and the SHA, so an identical request returns without calling the LLM. The pipeline only stops on parse errors and user input errors (invalid URL, repository or ref not found). If any other step fails, it is marked error or skipped and the analysis continues with what it has.

ErrLens

ErrLens

The pipeline is a single async generator (backend/app/pipeline.py). Each step emits an event, and the last one carries the full result. parse: Detects the language, the exception type and message, and all frames (innermost first), and separates user code from library code. Handles chained exceptions and warns about minified traces. resolve_paths: Resolves the ref to a commit SHA, fetches the repository tree and maps absolute trace paths (/home/deploy/app/user.py) to repository paths (app/user.py) by longest suffix match. fetch_context: Fetches ±20-line snippets for the first 3 user frames. If the source line in the trace does not match the repository, it warns and lowers the confidence. blame: Blames the lines around each error line. It then runs a related-commit search: if the error lines have not changed since then, it scores the patches of later commits in the same language against the identifiers and string literals on the error lines (for example '%Y-%m-%d'). This finds the cause when the line the trace points to is not the one that changed. analyze: Calls the LLM with a forced tool call. The output is validated in two layers: first the schema, then the semantics (the file and line range must be inside the shown snippet, the diff must build, and the code must pass a Python/JS syntax check). On failure, the error goes back to the model and it gets one retry. If it still fails, the result is returned without a fix. build_fix: Turns the edit into a unified diff with difflib; the LLM never writes the diff itself. The confidence score is 0.6 × LLM confidence + 0.4 × average of signals. The signals are: user frame resolved, change within the last 14 days, error type matches the line, fix validated, trace lines match the commit. done: Saves the result to SQLite. The cache key is a hash of the normalized trace, the repository and the SHA, so an identical request returns without calling the LLM. The pipeline only stops on parse errors and user input errors (invalid URL, repository or ref not found). If any other step fails, it is marked error or skipped and the analysis continues with what it has.

OnboardAI: Smart Dev Assistant

OnboardAI: Smart Dev Assistant

Problem: Joining a new engineering team or diving into a large open-source codebase is notoriously overwhelming. New developers spend days or even weeks struggling with undocumented code structures, setting up complex local development environments, tracing architecture dependencies, and trying to figure out where they can safely make their first contribution. This steep learning curve delays productivity, frustrates developers, and slows down overall team velocity. Solution: We built OnboardAI, an intelligent developer onboarding assistant designed to bridge this gap instantly. By leveraging IBM Bob, our system deeply analyzes codebases, breaks down system architectures, auto-generates step-by-step local setup instructions, and pinpoints tailored "good first issues" or starter tasks based on the developer's experience level. Target Users: New software engineers entering corporate tech environments. Open-source maintainers and contributors looking to lower the barrier to entry for newcomers. Engineering managers aiming to ramp up team members faster. User Interaction & Workflow: Developers point the assistant to a repository link. OnboardAI instantly scans the project files, renders an interactive architectural overview map, provides automated setup commands, and offers an interactive conversational guide where developers can ask questions like, "Where is user authentication handled?" or "What task should I pick up first?" Creativity, Uniqueness & Efficiency: Unlike generic documentation scrapers, OnboardAI dynamically parses context directly from the code structure in real-time. By turning static, boring documentation into an interactive, AI-driven mentor, it cuts traditional multi-week onboarding timelines down to just a few hours.

OnboardAI: Smart Dev Assistant

OnboardAI: Smart Dev Assistant

Problem: Joining a new engineering team or diving into a large open-source codebase is notoriously overwhelming. New developers spend days or even weeks struggling with undocumented code structures, setting up complex local development environments, tracing architecture dependencies, and trying to figure out where they can safely make their first contribution. This steep learning curve delays productivity, frustrates developers, and slows down overall team velocity. Solution: We built OnboardAI, an intelligent developer onboarding assistant designed to bridge this gap instantly. By leveraging IBM Bob, our system deeply analyzes codebases, breaks down system architectures, auto-generates step-by-step local setup instructions, and pinpoints tailored "good first issues" or starter tasks based on the developer's experience level. Target Users: New software engineers entering corporate tech environments. Open-source maintainers and contributors looking to lower the barrier to entry for newcomers. Engineering managers aiming to ramp up team members faster. User Interaction & Workflow: Developers point the assistant to a repository link. OnboardAI instantly scans the project files, renders an interactive architectural overview map, provides automated setup commands, and offers an interactive conversational guide where developers can ask questions like, "Where is user authentication handled?" or "What task should I pick up first?" Creativity, Uniqueness & Efficiency: Unlike generic documentation scrapers, OnboardAI dynamically parses context directly from the code structure in real-time. By turning static, boring documentation into an interactive, AI-driven mentor, it cuts traditional multi-week onboarding timelines down to just a few hours.