Conve

Conve_Logo
Conve_LogoName

Inspiration

Every team inside a company needs to interact and exchange with another team in order to progress in their tasks. Take a designer who needs to submit the result of their research to another team. Do you think everyone can understand "A/B Testing", "visual hierarchy" or "Breadcrumb"? These words can sound simple and complicated at the same time. People might also have their own interpretation. Then, naturally, we might ask : "what does that mean?" which creates a thread that turns one message into ten. Moreover, the decision that one team makes in week 1 can quietly contradict what another team decided in week 2, and nobody will notice it until it blows up in execution.

The hackathon problem statement asked "how AI might help multi-disciplinary teams make sense of information, present ideas, align on decisions, and review work more effectively".

Our idea: not another chat app, but a translation layer that sits between teams and does the work of "explaining this so the other side actually understands it" automatically.

What it does

Conve turns each team's documents into an understandable and easy way to communicate. Every upload is decomposed into topic nodes and atomic claims: facts, decisions, constraints, requirements, metrics, dates, owners, so the system understands what was actually said, not just the text it was written in.

Conve has four majors features, that will surely help you in your daily company life :

Adapts content to the receiving team's language. Every handoff is re-expressed in the receiving team's vocabulary and level of detail, based on that team's profile with the original always one click away. Every generated version is checked by a Rendition Judge before anyone sees it, because adaptation is the one step in the pipeline where no human is double-checking the AI's output.
Catches contradictions before they cross a team boundary. New documents are linked into the existing graph, and if something conflicts with what's already there, it's flagged for a human to resolve,never silently merged.
Scans for cross-team collisions at send time. Before Team A hands work to Team B, Conve checks the content against Team B's own graph.
Turns feedback into a real review process. The receiver reviews incoming content like a code review inline suggestions anchored to specific nodes which the sending team can accept, edit, or reject. Accepted suggestions actually update the source graph, so feedback stops dying in a chat thread.

How we built it

We split the system into a decomposition/ingestion pipeline and a send-time pipeline, with a shared Postgres + pgvector data layer underneath.

Frontend: Next.js (App Router) with React, Tailwind, and shadcn/ui for a card- and list-heavy interface built around channels, posts, and review queues. API: FastAPI (Python), with SQLAlchemy and Alembic for the domain layer and a background job table for the multi-step LLM pipelines (ingestion and send-time adaptation), so nothing blocks a request thread. Data: PostgreSQL via Supabase, using pgvector for embeddings and native Postgres full-text search for hybrid retrieval — one engine for both relational data and semantic search. Agents: A chain of purpose-built agents — Decomposition, Claim Extraction, Linking, Adaptation, and Prioritization — each with a strict JSON-schema output contract, plus a single runtime Rendition Judge that scores every adapted piece of content on fidelity and audience fit before it's shown to a reader. Auth & storage: Better Auth for sessions, Supabase Storage for uploaded documents, with signed URLs for upload/download. Deployment: Vercel for the app and API, Supabase for data and storage — no extra infrastructure to stand up on a hackathon timeline.

Challenges we ran into

Difficulty managing our time, especially the first half 12 hours. Finding and choosing an idea that answers the problem was quite challenging.
Deciding how much of the "graph" should actually be user-facing. We decided to remove the node from the users' perspective. Scoping that down to a topic tag on each post, rather than a full graph UI, was a hard but necessary cut.
Getting conflict detection to run at the right time. Running it too early (on every edit) was noisy; running it only on receipt was too late. We settled on scanning twice: once internally when content is ingested, and once cross-team at the moment of sending which meant rethinking the pipeline order more than once.
Making the AI's adaptation trustworthy without a human checking every single output. This is why the Rendition Judge exists. However, designing a judge that reliably catches when a "translation" drifted from the original meaning, without just rubber-stamping everything, took several iterations.

Accomplishments that we're proud of

Shipped a working full-stack MVP in 24 hours with techstacks: Next.js 16 + FastAPI + Supabase + Mistral, covering onboarding, org/team creation, versioned team profiles, document ingestion, a cross-team channel feed (search, pagination, decisions), and a dual-approve suggestion review workflow.
Built the AI pipeline end-to-end system.

What we learned

We've learned how to work in the intense enviroment that limited by limited time.
We've learned on how to work with the AI agentic and how to code them by using creating feature from PRD.md file practice.

What's next for Conve

Implementation : Dispatch tasks, timeline (gantt), automatisation file classification,
Exploring a lightweight, optional graph visualization for teams that do want to see the full topic structure, without forcing it on everyone else.
Summarise of