UnifAI - Team Orchestration for Software Delivery

AI agents plan, draft, and review your team's work using shared project context from GitHub and our platform - humans stay in the loop to approve plans and finalize the last additions.

Comment

UnifAI – Shared Context for Autonomous AI Teammates

Inspiration

Teams lose time to messy project management overhead, fragmented context, and unclear task distribution.

AI agents make this worse when they operate without shared project reality. They lack context, cannot iterate autonomously, and cannot coordinate across workstreams.

We built UnifAI to unify team context and enable agents to plan, execute, and iterate within real project constraints.

What it does

UnifAI is a team orchestration platform where AI agents and humans collaborate through shared structured context.

A project manager creates a task. The task is immediately sent to an Orchestration Agent that:

  • Plans the best course of action
  • Selects the appropriate specialist agents
  • Proposes task ownership

After PM approval, execution begins.

You can watch agent reasoning and activity in real time.

A specialist agent produces an 80% draft. The assigned team member completes the final 20% instead of starting from scratch.

UnifAI also includes:

  • A marketplace where teams select or publish specialist agents
  • Revenue sharing for public agents
  • A Context Explorer to inspect and edit shared context
  • External service connections to enrich agent inputs
  • Seat-based billing via Stripe
  • Token-based usage metering via Paid.ai

The result: faster delivery with governed, contextual AI execution.

How we built it

Backend: - Python + FastAPI

  • SQLAlchemy + SQLite
  • LangGraph state machine for orchestration
  • Claude-powered reasoning
  • Deterministic lifecycle state transitions

Frontend: - React + Vite + TypeScript + Tailwind

AI Infrastructure: - Hosted specialist agents

  • Marketplace agent registry
  • Real-time reasoning logs via SSE
  • Context normalization layer
  • GitHub ingestion and synchronization

Monetization: - Stripe seat subscriptions

  • Paid.ai token usage metering

We implemented the full task lifecycle:

Create → Plan → PM Approval → Agent Draft → Human Finalization → Reviewer Gate → Context Update → Billing.

Challenges we ran into

Context quality was the hardest problem.

It is not enough to store data. Context must be structured, fresh, normalized, and prompt-ready.

State transitions between planning, approval, and execution were brittle until lifecycle guarantees were enforced.

We also had to ensure no agent executes before explicit PM approval.

Real-time reasoning streaming required careful synchronization to avoid breaking task state.

Accomplishments that we're proud of

  • End-to-end governed AI task execution
  • Real-time reasoning visibility
  • Deterministic PM approval gating
  • Structured shared context model across projects
  • Agent marketplace with publish and revenue model
  • Context Explorer UI
  • Stripe subscription integration
  • Token-level billing integration with Paid.ai
  • Live demo environment

Built in 24 hours by a team of four.

What we learned

AI without structured context becomes autocomplete with better wording.

Human governance is essential for trust.

The hardest part is not calling an LLM. It is designing reliable infrastructure around it.

Shared context is the real competitive advantage.

What's next

  • Automatic shared context refresh from connected services
  • Stronger autonomous iteration on open tasks
  • Deeper merge-conflict prediction
  • Expanded token-level billing analytics
  • More powerful context editing and versioning
  • Subtask lifecycle parity

Try it out

Built With

Share this project:

Updates