Table of Contents

• Table of Contents
• About the Project
  • Screenshots
  • Architecture
  • Features
  • Tech Stack
• Getting Started
  • Prerequisites
  • Installation
  • Running the Project
• FAQ

About the Project

A multi-agent orchestration platform simulating a high-stakes investment committee, where adversarial AI Agents critique and negotiate startup pitches. Features conflict-driven workflows and distinct strategic personalities in a technical homage to Shark Tank.

Screenshots

Coming soon...

Architecture

The project has 3 main components:

• Backend - FastAPI service that hosts the agent orchestration logic.
• MCP Server - MCP Server that exposes common tools and prompts to the agents.
• Web Client - React App that allows users to communicate with the system.

Features

• Adversarial Agent Topology: Simulates a "Mixture of Experts" committee where distinct AI personalities actively debate and critique pitches from conflicting viewpoints.

• Grounded Intelligence via MCP: Eliminates hallucination using a custom Model Context Protocol (MCP) server that validates user claims against real-world data like market multiples.

• Dynamic Bidding War Engine: Triggers autonomous, state-managed negotiation loops where agents compete and undercut offers based on their specific risk profiles.

• Orchestrated State Machine: Leverages LangGraph to manage complex state transitions, intelligently routing users between global rejection, single offers, and competitive bidding wars.

• Structured Deal Artifacts: Produces concrete, actionable outputs—either a structured Deal Memorandum or a data-backed rejection summary—rather than generic chat.

• Dockerized & Local-First: Features a fully containerized architecture (FastAPI + React + Postgres) that supports both cloud inference and privacy-focused local execution (Ollama) out of the box.

Tech Stack

Web

• TypeScript
• React
• Vite

Backend

• Python
• FastAPI
• PostgreSQL
• LangGraph
• Ollama
• UV

MCP

• Python
• FastMCP
• UV

DevOps

• Docker
• Github Actions

Getting Started

Prerequisites

• Docker Desktop: This project runs entirely in containers. If you don't have it, install it here.
• Resources: If using local LLMs (Ollama), ensure Docker is allocated at least 8GB-16GB of RAM.

Installation

1. Clone the repository:

   git clone https://github.com/praevalis/turing-tank.git
   cd turing-tank
   

2. Configure Environment Variables: Copy the example configuration

   cp .env.template .env
   # Open .env in your editor and fill in the blanks!]
   

Running the Project

docker compose up -d

Note: Expect a longer processing time for the first run while Ollama downloads the necessary LLM files.

FAQ

• Why use Multi-Agent System (MAS) instead of one big prompt?

  • A single LLM struggles to hold conflicting viewpoints simultaneously (e.g., loving the tech but hating the business model).
  • By splitting the concerns into distinct agents — Financier, Techie, Brand and Empathetic Closer; we create a "Mixture of Experts" topology that provides a much deeper, multifaceted critique of your startup.

• Do the agents just talk over each other?

  • No. We use LangGraph to enforce a strict state machine. The orchestration layer manages the conversation flow, ensuring agents only speak during their turn (e.g., "Pitch Phase" vs. "Bidding War").
  • It also detects conflicts if two agents are interested, it triggers a specialized "Negotiation Sub-Graph" where they must undercut each other's offers.

• How do agents avoid hallucinating valuations?

  • Unlike standard chatbots, Turing Tank agents are grounded by a custom MCP (Model Context Protocol) Server. When Agent Royalty calculates a valuation, he isn't guessing; he is calling a Python tool that fetches real-time sector P/E ratios and performs a deterministic calculation.
  • The agents provide the personality, but the MCP server provides the facts.