Syncline

The invisible scheduling layer for AI agents

🌐 Live at syncline.run - Experience the beautifully designed interface and see Syncline in action!

🎯 What is Syncline?

Syncline is an AI-powered calendar coordination platform that enables AI agents to automatically schedule meetings between people using natural language. Instead of complex API integrations, AI agents simply describe what they need in plain English, and Syncline handles the rest.

For example, an AI agent can say:

"Schedule a 30-minute meeting between Alice and Bob sometime next week in the afternoon"

Syncline will:

Check both calendars for availability
Find optimal time slots based on preferences
Create the meeting with Google Meet link
Send calendar invites to both attendees

All automatically. No human intervention required.

🏗️ Architecture

Syncline is built as a high-performance, multi-tenant platform designed specifically for AI agent integration.

System Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│                        AI Agents Layer                          │
│  (Claude, GPT-4, Custom Agents via MCP or REST API)           │
└────────────────────────┬────────────────────────────────────────┘
                         │
                         │ MCP Protocol / REST API
                         ▼
┌─────────────────────────────────────────────────────────────────┐
│                     Syncline Platform                           │
│                                                                 │
│  ┌──────────────┐      ┌──────────────┐      ┌──────────────┐ │
│  │  MCP Server  │      │  REST API    │      │   Frontend   │ │
│  │  (Go)        │◄────►│  (Go)        │◄────►│  (Next.js)   │ │
│  └──────────────┘      └──────────────┘      └──────────────┘ │
│         │                      │                      │         │
│         │                      ▼                      │         │
│         │             ┌──────────────┐               │         │
│         │             │    Redis     │               │         │
│         │             │  (Cache +    │               │         │
│         └────────────►│ Rate Limit)  │◄──────────────┘         │
│                       └──────────────┘                         │
│                              │                                  │
│                              ▼                                  │
│         ┌───────────────────────────────────────┐             │
│         │          Firestore Database           │             │
│         │  • User Profiles & OAuth Tokens       │             │
│         │  • Meeting History & Preferences      │             │
│         │  • Platform Configs & API Keys        │             │
│         └───────────────────────────────────────┘             │
│                              │                                  │
└──────────────────────────────┼──────────────────────────────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │  Google Calendar    │
                    │  API Integration    │
                    └─────────────────────┘

Key Components

1. MCP Server (Model Context Protocol)

The heart of Syncline's AI integration. Exposes 4 powerful tools:

get_availability - Find when people are free
schedule_meeting - Book a meeting automatically
get_user_meetings - View scheduled meetings
cancel_meeting - Cancel meetings

Available on the MCP Registry in 3 languages:

TypeScript: @kekwanulabs/syncline-mcp-server
Go: @kekwanulabs/syncline-mcp-server-go
Python: syncline-mcp-server

2. Redis Integration (r/AI_Agents Hackathon Feature!)

Critical for production-grade AI agent platforms:

Rate Limiting:

Sliding window algorithm prevents API abuse
Per-API-key limits (e.g., 100 requests/minute)
Protects against runaway AI agents

Caching:

Availability queries cached for 5 minutes
Reduces Google Calendar API calls by 80-90%
Sub-100ms response times for cached queries

Distributed Locking:

Prevents race conditions when multiple agents schedule simultaneously
Ensures calendar consistency across concurrent requests

Webhook Queue:

Reliable event delivery to AI platforms
Exponential backoff retry logic
Dead letter queue for failed deliveries

3. AI Learning System

Syncline learns from meeting outcomes using reinforcement learning:

Tracks which time slots lead to successful meetings
Learns user preferences (morning vs afternoon, day of week)
Adjusts smart ranking weights automatically
Cloud Scheduler runs learning algorithm every 5 minutes

4. Smart Slot Ranking Algorithm

Not all free time slots are equal. Syncline ranks slots based on:

Recency bias: Sooner slots ranked higher
Time-of-day preferences: Learned from user history
Day-of-week patterns: Some users prefer certain days
Context similarity: Matches similar meeting types
Buffer time: Respects user's desired spacing between meetings

5. Multi-Platform Architecture

Organizations can create unlimited "platforms" (e.g., different AI agents, apps, websites)
Each platform gets its own API keys, webhooks, and OAuth configs
Aggregate usage tracking at organization level
Team member management with role-based access (owner, admin, member, viewer)

🤖 Why Syncline for AI Agents?

Traditional Approach (Complex)

AI agents need to:

Understand calendar APIs for each provider (Google, Outlook, Apple)
Handle OAuth flows and token management
Parse availability data and compare time zones
Deal with edge cases (all-day events, recurring meetings, conflicts)
Create meetings with proper formatting
Handle rate limits and retries

Result: Months of development, hundreds of lines of code, constant maintenance.

Syncline Approach (Simple)

AI agents simply call one MCP tool:

// That's it. Syncline handles everything.
await use_mcp_tool({
  server_name: "syncline",
  tool_name: "schedule_meeting",
  arguments: {
    attendees: ["alice@example.com", "bob@example.com"],
    duration_minutes: 30,
    title: "Project Discussion",
    preferred_times: "next week afternoons"
  }
})

Result: 5 minutes to integrate, 3 lines of code, zero maintenance.

Natural Language Understanding

Syncline's MCP server understands natural language preferences:

"next week" → Searches 7-14 days out
"mornings" → Prioritizes 9am-12pm slots
"afternoons" → Prioritizes 1pm-5pm slots
"ASAP" → Returns earliest available slots
"after 3pm" → Only shows slots after 3pm

The AI agent doesn't need to parse these - just pass them through, and Syncline handles the interpretation.

🚀 Live Demo

Visit syncline.run to experience:

Beautiful, animated landing page
Smooth OAuth flow with Google Calendar
Interactive preference setup
Real-time availability visualization
Instant API key generation

The frontend is built with Next.js 14, Tailwind CSS, and Framer Motion for buttery-smooth animations and a delightful user experience.

🛠️ Tech Stack

Backend (Go):

MCP Go SDK (github.com/mark3labs/mcp-go)
Google Cloud Firestore (database)
Google Calendar API v3
Redis (rate limiting, caching, distributed locking)
Cloud Run (serverless deployment)

Frontend (Next.js 14):

App Router with Server Components
Tailwind CSS + Framer Motion
Real-time updates via Firestore
Cloudflare Pages (deployment)

Infrastructure:

GitHub Actions (CI/CD)
Google Cloud Platform
Cloudflare (frontend hosting + CDN)
Mintlify (API documentation)

📋 Key Features

Production Ready

✅ Google Calendar integration with encrypted OAuth tokens
✅ 2-person meeting scheduling (3-10 person support coming soon)
✅ Configurable meeting duration (default 30 minutes)
✅ Smart buffer time between meetings (15min default)
✅ Flexible availability window (14 days default)
✅ AI-powered slot ranking algorithm
✅ Automatic Google Meet link creation
✅ MCP server for AI agents (TypeScript, Go, Python)
✅ REST API for direct HTTP access
✅ Redis-backed rate limiting and caching
✅ Webhook support for real-time event notifications
✅ Multi-platform architecture for organizations
✅ Team member management with role-based access
✅ Real-time frontend updates
✅ Comprehensive API documentation

Coming Soon

⏳ Outlook & Apple Calendar support
⏳ Zoom & Microsoft Teams integration
⏳ Advanced scheduling preferences
⏳ Analytics dashboard
⏳ Recurring meeting support

🔌 Quick Integration

For AI Agents (MCP)

# Install via Claude Desktop config
npm install @kekwanulabs/syncline-mcp-server

{
  "mcpServers": {
    "syncline": {
      "command": "npx",
      "args": ["@kekwanulabs/syncline-mcp-server"],
      "env": {
        "SYNCLINE_API_KEY": "sk_live_your_api_key_here"
      }
    }
  }
}

For Developers (REST API)

// Find availability
const response = await fetch('https://api.syncline.run/v1/availability', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_live_xxx',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    attendees: ['alice@example.com', 'bob@example.com'],
    duration_minutes: 30
  })
})

const slots = await response.json()
// Returns ranked time slots both people are available

// Schedule meeting
await fetch('https://api.syncline.run/v1/schedule', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_live_xxx',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    attendees: ['alice@example.com', 'bob@example.com'],
    start_time: slots.slots[0].start_time,
    duration_minutes: 30,
    title: 'Project Discussion'
  })
})

Full API documentation: kekwanulabslllc.mintlify.app

🎨 Design Philosophy

Syncline is designed to be invisible infrastructure for AI agents. Like Stripe for payments or Twilio for SMS, Syncline handles all the complexity of calendar coordination so AI agents can focus on their core functionality.

Key Principles:

Simple Integration - 5 minutes to get started
Natural Language - AI agents don't need to understand calendar APIs
Production Grade - Rate limiting, caching, distributed locking
Multi-Tenant - Built for platforms with thousands of users
Real-Time - Webhook events keep AI agents in sync

🏆 Hackathon Project

This project was built for the r/AI_Agents Hackathon. It showcases:

Redis Integration (Hackathon Sponsor):

Rate limiting with sliding window algorithm
Availability caching (80-90% API call reduction)
Distributed locking for concurrent scheduling
Webhook retry queue with exponential backoff

AI Agent Focus:

MCP server implementation in 3 languages
Natural language preference understanding
Smart ranking algorithm with reinforcement learning
Production-ready for real AI agent platforms

Full-Stack Excellence:

Beautiful, responsive frontend (Next.js + Tailwind)
High-performance backend (Go + Redis + Firestore)
Comprehensive documentation
Live deployment with CI/CD

🚀 Quick Start

Prerequisites

Go 1.25+
Node.js 18+
Google Cloud Project
Redis instance (optional for local dev)

Local Development

# Clone the repository
git clone https://github.com/KekwanuLabs/syncline.git
cd syncline

# Backend setup
cd backend
cp .env.example .env
# Edit .env with your credentials
go mod download
go run cmd/server/main.go

# Frontend setup (in another terminal)
cd frontend
npm install
cp .env.example .env.local
# Edit .env.local
npm run dev

Visit http://localhost:3000 to see the frontend. Backend API available at http://localhost:8080.

For detailed setup instructions, see SETUP.md.

📚 Documentation

API Reference: kekwanulabslllc.mintlify.app
Architecture Guide: project-docs/ARCHITECTURE.md
Setup Guide: project-docs/SETUP.md
Development Guide: project-docs/DEVELOPMENT.md

📁 Project Structure

syncline/
├── backend/                 # Go backend server
│   ├── cmd/server/          # Main entry point
│   ├── internal/api/        # REST API handlers
│   ├── internal/mcp/        # MCP server implementation
│   ├── internal/intelligence/ # AI learning system
│   └── pkg/                 # Shared packages
├── frontend/                # Next.js frontend
│   ├── app/                 # App Router pages
│   ├── components/          # React components
│   └── lib/                 # Utilities & hooks
├── mcp-server/              # TypeScript MCP server
├── mcp-server-go/           # Go MCP server (standalone)
├── mcp-server-python/       # Python MCP server
├── docs/                    # API documentation (Mintlify)
└── project-docs/            # Architecture & guides

🎨 Design System

Colors:

Primary: #6366F1 (Indigo) - Trust & professionalism
Secondary: #8B5CF6 (Purple) - Innovation & AI
Accent: #06B6D4 (Cyan) - Energy & action
Success: #10B981 (Green) - Confirmation

Typography:

Sans: Geist Sans (clean, modern)
Mono: Geist Mono (code, API keys)

Animations:

Framer Motion for smooth page transitions
CSS transitions for micro-interactions
0.2s duration for most UI changes

🤝 Contributing

This is a hackathon project and not currently open for contributions. However, feedback and suggestions are welcome!

📄 License

Proprietary - Kekwanu Labs

🙋 Support

Documentation: kekwanulabslllc.mintlify.app
Email: help@syncline.run
Website: syncline.run

🏅 Credits

Built with ❤️ for the r/AI_Agents Hackathon

Technologies:

MCP (Model Context Protocol) by Anthropic
Redis for caching and rate limiting
Google Cloud Platform for infrastructure
Next.js for the frontend
Go for the backend

Special Thanks:

Claude Code by Anthropic for development assistance
r/AI_Agents community for feedback and support

⭐ If you find Syncline useful, please star this repository!

syncline-mcp-server

Documentation