Paripari

Inspiration

AI coding agents are incredible, but they all run into the same wall: token limits. When an agent tries to autonomously explore a large repository, it quickly consumes the context window and triggers rate limits (like Groq's strict TPM limits). We realized that while LLMs need context to fix bugs, they don't need every single raw character of a codebase. We were inspired to build an agent that could "see" the whole repository without blowing up the token budget.

What it does

PariPari is an autonomous, repo-aware AI copilot. You give it a GitHub repository and a prompt (e.g., "Why is authentication failing?"), and PariPari will independently map the codebase, read relevant files, propose minimal unified diff patches, and even write the PR summary.

The magic lies in its integration with Paritok—every time the agent reads a file or lists a directory, the output is passed through a semantic compression proxy. This shrinks the context footprint by 70-80%, allowing the agent to navigate massive codebases on free-tier models without hitting token per minute (TPM) limits.

How we built it

Backend: Python and FastAPI to manage the agent loop, tool execution, and GitHub API interactions.
Frontend: A sleek Next.js (React) UI that streams server-sent events (SSE) to show the agent's thought process, tool calls, and proposed code diffs in real-time.
AI/LLM: We used the Groq API (Llama-3 models) for lightning-fast inference.
Compression: The Paritok API compresses raw code/tool outputs into dense semantic text before feeding it back to the LLM.
Repo Mapping: We used the GitHub Trees API to fetch the entire repository structure in a single, efficient API call.

Challenges we ran into

Token Explosions: Early on, we tried injecting the entire repository file map into the initial system prompt. We immediately hit Groq's 12,000 TPM limit (Error 413) because the raw JSON map was over 28,000 tokens! We solved this by forcing the agent to explore dynamically, keeping the context window tight and compressing every step.
GitHub Rate Limits: Our initial naive crawler hit GitHub's unauthenticated 60 requests/hour limit instantly. We had to rewrite the indexer to use the recursive Trees API and add authenticated token support (bumping our limit to 5,000 req/hr).

Accomplishments that we're proud of

Achieving an average of 70-80% token reduction on codebase file reads using Paritok compression without the LLM losing context or hallucinating.
Building a seamless, real-time streaming UI where users can watch the agent "think" and execute tools sequentially.
Creating an agent that actually works within the tightest developer constraints (free tier rate limits).

What we learned

We learned that context size isn't everything; Tokens Per Minute (TPM) is the real bottleneck for autonomous agents. Feeding raw tool outputs to an LLM is incredibly inefficient. Compressing intermediate tool outputs (like file contents and directory listings) is an absolute game-changer for building scalable, affordable AI agents.

What's next for Paripari

GitHub App Integration: Turning PariPari into a GitHub bot that automatically reads newly opened issues, investigates the codebase, and submits a PR with the fix.
Multi-Agent Collaboration: Splitting the workload between a "Researcher Agent" that builds the context map and an "Execution Agent" that writes the code.
Local File System Support: Expanding beyond GitHub URLs to allow PariPari to work locally in any IDE.