Tzylo — The Context Layer for Engineering Teams

The Problem

Engineering managers have to maintain context across too many disconnected systems.

Important decisions and commitments happen in meetings. Actual engineering work happens in GitHub. Tasks and follow-ups are often tracked somewhere else—or simply remembered by someone.

This creates a gap between what the team said it would do and what is actually happening.

A manager might know that an engineer committed to fixing an issue in a meeting, but then have to manually search through GitHub to determine whether the work was started, whether a PR exists, whether it is blocked, and whether the original commitment is still on track.

We wanted to solve that context fragmentation.

What We Built

Tzylo combines meeting conversations and GitHub activity into a unified organizational context for engineering managers.

Tzylo processes meeting conversations to identify important engineering context such as:

• Decisions
• Commitments
• Tasks
• Owners
• Deadlines
• Blockers
• Follow-ups

It then connects that context with engineering activity in GitHub, including issues, pull requests, commits, reviews, and other relevant activity.

This allows Tzylo to track the lifecycle of engineering work from the original conversation to the actual implementation.

Meeting → Commitment → GitHub Activity → Progress

Instead of asking managers to manually connect these systems, Tzylo creates those connections automatically.

The Agent

The interesting part of Tzylo is not simply summarizing a meeting.

The system needs to reason across different sources of organizational information.

An agent can take a statement such as:

"I'll fix the authentication issue tomorrow."

and connect it to the relevant engineering work in GitHub.

Later, the manager can ask questions such as:

• What commitments came out of yesterday's meetings?
• Which tasks are currently blocked?
• What did we agree to do, and what has actually happened?
• Which commitments have not yet been followed through?
• What changed since our last meeting?

Tzylo uses the combined context to answer these questions rather than treating meetings and GitHub as isolated data sources.

How We Built It

Tzylo is built around a pipeline that ingests meeting and engineering data, extracts structured context, connects related entities, and makes that context available to an AI system.

The system combines:

• Meeting transcription and analysis
• LLM-based extraction of tasks, decisions, commitments and blockers
• GitHub data
• Entity and task matching
• Retrieval over organizational context
• Agentic reasoning over the resulting context

A major focus was designing the intermediate organizational context instead of simply sending raw meeting transcripts or GitHub data directly to an LLM.

Challenges

The hardest problem was connecting meaning across sources.

People rarely use the exact same words in meetings and GitHub. A meeting may refer to "the auth problem" while GitHub contains a specific issue, branch, or pull request with completely different wording.

We therefore had to think about how to extract useful signals from conversations and connect them with real engineering artifacts without relying entirely on exact keyword matching.

Another challenge was making the system useful without overwhelming managers with more information. The goal is not to surface everything—it is to surface the context that actually requires attention.

What We Learned

Building Tzylo reinforced an important lesson about AI agents:

The quality of an agent depends heavily on the quality and structure of the context it can access.

A powerful model alone does not solve organizational context fragmentation. The system needs to understand where information came from, how different pieces of information relate to each other, and how those relationships change over time.

Tzylo is our attempt to build that missing context layer for engineering teams.

Built With

• ai-agents
• fastapi
• github-api
• llms
• next.js
• pgvector
• postgresql
• python
• rag
• vector
• vexa