Project Info

Tissue.AI

Inspiration

One of the biggest barriers for new developers is knowing where to start when contributing to open-source projects. Staring at unfamiliar codebases with hundreds of files can be overwhelming, especially when trying to understand how to fix a specific GitHub issue. We wanted to create an AI-powered tool that bridges this gap by providing newcomers with the context, guidance, and confidence they need to make their first meaningful. Furthermore, LLM agents are still not (yet) great at solving real-world coding problems— the best performing agent in SWE-bench (popular coding benchmark) as of this writing can only solve ~50% of GitHub PRs. Human engineers are still essential in the open-source software ecosystem today, especially as the amount of software continues to grow.

What it does

Our project helps users understand and guide them along the process of fixing github repo issues. The client pastes the link of an issue they're working on, and we use agent orchestration to process the repository and the specific files that the issue targets. Our system collects data persistently through Letta's MemGPT technology and synthesizes information in an interactive and easy-to-grok format for users. The structured and specific data can greatly benefit developers new to the project. Developers can also use this data to continue solving the issue through agentic code agents like Cursor and Copilot.

How we built it

Front-end: We use Next.js for server-side rendering and routing. All UI components are built with React. Styling is handled with Tailwind CSS utility classes, along with custom CSS that creates a “liquid glass” (glassmorphism) effect for a modern interface. The Monaco Editor is integrated to provide an interactive, IDE-like code viewer, allowing users to explore code with syntax highlighting and a smooth user experience. Back-end: The backend is built with FastAPI and leverages Letta and MCP tools to analyze GitHub issues. When a user submits a GitHub issue URL, the backend fetches the issue details and repository structure, analyzes the codebase, architecture, and build/test commands, and generates a summary of the issue, project context, and implementation steps. This information is returned as a JSON object that matches a Pydantic model schema, making it easy for the frontend to process and display the data.

Challenges we ran into

Letta Integration Complexity: Learning to work with Letta's agent-based architecture and coordinating multiple AI agents required significant experimentation MCP Server Configuration: Setting up and properly connecting Model Context Protocol servers for GitHub integration Schema Design: Creating comprehensive Pydantic schemas that could handle the variety of repository structures and issue types Asynchronous Workflow Management: Coordinating between supervisor and worker agents while maintaining response reliability CORS and Environment Configuration: Ensuring proper API communication between frontend and backend across different environments

Accomplishments we're proud of

Successfully implemented Letta's multi-agent system for complex repository analysis Mastered MCP server integration to directly interface with GitHub's API and repository contents Created an intuitive glassmorphism UI that makes complex technical information accessible Built a full-stack application from scratch during the hackathon timeframe Designed a scalable architecture that can handle repositories of varying sizes and complexity Delivered real value by solving a genuine problem faced by new open-source contributors

What's next

We're considering making the output more interactive, such as adding a chatbot so users can ask more questions about the current issue and get more tailored responses than the general overview. Beyond this, we plan to expand support for multi-repository analysis to handle issues that span across multiple codebases or dependencies. We're also exploring the development of personalized learning path generation that would recommend relevant tutorials and concepts based on the technologies encountered in each issue. To foster collaboration, we want to introduce community features that allow users to share their analysis results and work together on solutions. Additionally, we're considering building IDE extensions that would bring Tissue.AI directly into developers' workflows within popular code editors. Finally, we're looking into implementing an AI-powered difficulty scoring system that would help users find issues that match their current skill level, creating a more tailored and progressive learning experience for new contributors.

Tissue.AI 🤖

Supercharging open source contributions. Paste any GitHub issue URL and our agent analyzes the codebase to provide step-by-step guidance to help newcomers confidently tackle their first contribution.

Inspiration 💡

What It Does 🎯

Our project helps users understand and guide them along the process of fixing GitHub repo issues. The client pastes the link of an issue they're working on, and we use agent orchestration to process the repository and the specific files that the issue targets. Our system collects data persistently through Letta's MemGPT technology and synthesizes information in an interactive and easy-to-grok format for users. The structured and specific data can greatly benefit developers new to the project.

How We Built It 🛠️

Frontend:

Next.js: For server-side rendering and routing.
React: For building UI components.
Tailwind CSS: For utility-first styling.
Monaco Editor: For an interactive, IDE-like code viewer.

Backend:

FastAPI: For building the backend server.
Letta & MCP: To analyze GitHub issues and repositories.
Pydantic: For data validation and schema management.

Key Features ✨

Multi-Agent System: Utilizes Letta for complex repository analysis.
Intuitive UI: A glassmorphism UI that makes technical information accessible.
Scalable Architecture: Can handle repositories of varying sizes and complexity.
Full-Stack Application: Built from scratch during the hackathon timeframe.

Getting Started 🚀

Prerequisites

Node.js 20+
Python 3.12+
uv

Installation

Clone the repository:

git clone https://github.com/aaron-ang/tissue-ai.git

Install frontend dependencies:
```
cd frontend
npm install
```
Install backend dependencies:
```
cd backend
uv sync
cp .env.example .env
```
Then, add your LETTA_API_KEY to the .env file.

Running the Application

Start the backend server:
```
cd backend
uv run fastapi dev
```
Start the frontend development server:
```
cd ../frontend
npm run dev
```

Usage 📖

Open your browser and navigate to http://localhost:3000.
Paste a GitHub issue URL into the input field.
Click the "Analyze" button.
View the analysis, which includes a summary of the issue, project context, and implementation steps.

What's Next 🔮

Interactive Chatbot: To provide more tailored responses.
Multi-Repository Analysis: To handle issues that span across multiple codebases.
Personalized Learning Paths: To recommend relevant tutorials and concepts.
Community Features: To allow users to share analysis results.
IDE Extensions: To bring Tissue.AI directly into developers' workflows.

Meet the Team 👋

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

CSSIn code
JavaScriptIn code
Next.jsIn code
PythonIn code
ReactIn code
Tailwind CSSIn code
TypeScriptIn code
FastAPIClaimed
Google GeminiClaimed

7 of 9 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

66 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.