Slash Chain - Autonomous Value Delivery System

An AI-powered platform that automates end-to-end professional services operations from lead generation through project delivery to payment collection.

What is Slash Chain?

Slash Chain is an Autonomous Value Delivery System (AVDS) - an intelligent agent orchestration platform that automates the complete professional services business lifecycle. It uses AI agents to handle sales qualification, project planning, delivery management, and financial operations with minimal human intervention.

This isn't just sales automation - it's a complete operating system for professional services businesses.

The Vision

Transform professional services from manual, time-consuming processes into an automated, scalable system:

Lead → Opportunity → Proposal → SOW → Delivery → Acceptance → Billing → Payment
  ↓         ↓            ↓        ↓        ↓           ↓          ↓         ↓
Agent 1   Agent 2     Agent 3  Agent 4  Agents 5-12  Agent 13  Agent 14  Agent 15

Current Status (MVP - Epic 1)

We're starting with sales automation (highest ROI, fastest validation), then expanding through the full professional services lifecycle.

✅ Operational:

Lead research and qualification agent
Bidirectional HubSpot CRM integration
PostgreSQL database with engagement tracking
ASP.NET Core API
CLI dashboard for monitoring

🚧 In Development:

Opportunity Agent (strategic research)
Strategic Intent Agent (requirements gathering)
SOW Agent (proposal generation)

📋 Roadmap: Planning, Delivery, and Financial agents (see 15-agent pipeline below)

Key Features

Automated Lead Qualification

Intelligent Research: Agents automatically research incoming leads
Smart Scoring: 0-100 qualification scores based on fit analysis
Automatic Triage: Qualified/Review/Disqualified status assignment
Rich Metadata: Stores research findings for future reference

HubSpot CRM Integration

Bidirectional Sync: Pull contacts from HubSpot, push results back
Automatic Triggers: New contacts automatically trigger Lead Agent
Real-time Updates: Deal stages sync with engagement pipeline
Free Tier Compatible: Works with HubSpot Free (no credit card required)

Real-time Monitoring

CLI Dashboard: Beautiful terminal interface with live updates
Pipeline Visibility: Track engagements across all stages
Agent Activity: Monitor agent executions in real-time
Summary Statistics: Qualified leads, average scores, total engagements

Extensible Agent Framework

15 Agent Pipeline: Complete coverage from lead to payment
Sub-agent Architecture: Hierarchical decomposition for complex tasks
Parallel Execution: Multiple agents run concurrently
State Management: Robust tracking of engagement lifecycle

Research & Knowledge Tools

YouTube Transcript Extraction: Fetch transcripts from videos for research
Multiple Output Formats: Markdown, text, or JSON with timestamps
Multi-language Support: Extract transcripts in any available language
CLI Integration: Direct service invocation without API overhead

Business Value

For Professional Services Firms

Complete Lifecycle Automation - From first contact to final payment
10x Capacity Increase - 1 operator manages 20-50 concurrent engagements (vs 5-10 traditionally)
Consistent Delivery Quality - Standardized processes eliminate variability
Institutional Knowledge Capture - Every engagement documented and searchable
Predictable Operations - Automated workflows with defined SLAs

Time Savings Across the Lifecycle

Sales - 5-10 hours/week on lead qualification and opportunity research
Planning - 80% faster SOW generation and project scoping
Delivery - Automated work breakdown, tracking, and status reporting
Financial - Automatic invoicing, payment tracking, and collection

Economic Impact

Traditional Model: Linear scaling (more revenue = more people)
AVDS Model: Exponential scaling (fixed operator cost, unlimited capacity)
Result: Transform from services business to software-enabled services platform

The Numbers

Traditional: 1 person = 5-10 concurrent clients
With AVDS: 1 operator = 20-50 concurrent engagements across all stages
Time to Delivery: Days instead of weeks
Quality: Consistent, repeatable, improvable over time

Quick Start

Prerequisites

PostgreSQL 16+ - Database for engagements and agent execution logs
.NET 9.0 SDK - Runtime for API and CLI applications
Bash shell - For agent scripts (Linux/macOS/WSL)
Git - For cloning the repository
HubSpot account (optional) - Free tier is sufficient

Installation

Clone the repository:

git clone https://github.com/DecoupledLogic/slash-chain.git
cd slash-chain

Start PostgreSQL:
```
cd src
docker-compose up -d
```

Run database migrations:

dotnet ef database update --project SlashChain.Infrastructure --startup-project SlashChain.API

Configure HubSpot (optional):

Edit src/SlashChain.API/appsettings.json:

{
  "HubSpot": {
    "Enabled": true,
    "PrivateAppAccessToken": "your-token-here",
    "SyncIntervalSeconds": 300,
    "AutoTriggerLeadAgent": true
  }
}

Start the API:
```
cd src/SlashChain.API
dotnet run
```
Launch the dashboard:
```
cd src/SlashChain.CLI
dotnet run
```

For detailed setup instructions, see GETTING-STARTED.md.

Architecture

Tech Stack

┌─────────────────────────────────────────────────────┐
│                  OPERATOR INTERFACES                 │
├──────────────┬───────────────────┬──────────────────┤
│ Claude Code  │  C# Terminal UI   │   Nuxt Web UI    │
│  (Primary)   │   (Dashboard)     │   (Coming Soon)  │
└──────┬───────┴─────────┬─────────┴────────┬─────────┘
       │                 │                   │
       └─────────────────┼───────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│           ASP.NET CORE 8.0 WEB API (C# 12)          │
│  Engagement Service | Agent Orchestrator            │
│  HubSpot Integration | State Management             │
└────────────────────────┬────────────────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│              POSTGRESQL 16 DATABASE                  │
│  Engagements | Agent Executions | Agent Logs        │
└─────────────────────────────────────────────────────┘
                         ↑
┌─────────────────────────────────────────────────────┐
│            CLAUDE CODE + BASH AGENTS                 │
│  Lead Agent | Opportunity Agent | 13 more...        │
└─────────────────────────────────────────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│           EXTERNAL INTEGRATIONS                      │
│  HubSpot | GitHub | QuickBooks | Slack | Email      │
└─────────────────────────────────────────────────────┘

Core Components

API Layer (ASP.NET Core)

RESTful API for engagement management
Agent orchestration and execution
Integration with external services
Real-time updates via background services

Database Layer (PostgreSQL)

engagements - Lead/opportunity/project tracking
agent_executions - Agent run history and status
agent_logs - Detailed execution logs and decisions

Agent Layer (Bash + Claude Code)

Autonomous agents for each pipeline stage
Sub-agent architecture for complex tasks
State-based workflow execution

Integration Layer

HubSpot CRM (contacts, deals, custom properties)
GitHub Issues (work item tracking, coming soon)
QuickBooks (billing, coming soon)

Usage

API Endpoints

List all engagements:

curl http://localhost:5090/api/engagements

Get specific engagement:

curl http://localhost:5090/api/engagements/<id>

Create engagement:

curl -X POST http://localhost:5090/api/engagements \
  -H "Content-Type: application/json" \
  -d '{
    "leadName": "Acme Corporation",
    "leadEmail": "contact@acme.com",
    "leadPhone": "555-1234",
    "leadSource": "Website"
  }'

Trigger Lead Agent:

curl -X POST http://localhost:5090/api/agents/execute \
  -H "Content-Type: application/json" \
  -d '{
    "agentName": "lead-agent",
    "engagementId": "<id>"
  }'

Slash Commands

The system includes Claude Code slash commands for development and troubleshooting:

Troubleshooting & Development:

/troubleshoot <incident-id> - Automated troubleshooting workflow
/document-fix - Document solutions to the knowledge base
/write-tests - Generate comprehensive unit tests
/gather-requirements - Collect requirements for features
/getting-started - Interactive setup guide

Research & Knowledge:

/youtube-transcript <url> - Fetch YouTube video transcript for research

The 15-Agent Pipeline

Sales Stage (Agents 1-3)

Lead Agent ✅ - Research and qualification scoring
Opportunity Agent 🚧 - Strategic intake and discovery
Strategic Intent Agent 📋 - Requirements gathering and documentation

Planning Stage (Agents 4-6)

Initiative Agent 📋 - High-level decomposition and estimation
Project Agent 📋 - Charter creation and resource planning
SOW Agent 📋 - Pricing, terms, and document generation

Delivery Stage (Agents 7-12)

User Experience Agent 📋 - Research, wireframes, design
Epic Agent 📋 - Feature breakdown and prioritization
Feature Agent 📋 - Story creation and refinement
Story Agent 📋 - Task decomposition
Task Agent 📋 - Implementation tracking
Delivery Agent 📋 - Release management and deployment

Financial Stage (Agents 13-15)

Acceptance Agent 📋 - UAT coordination and sign-off
Billing Agent 📋 - Invoice generation and submission
Payment Agent 📋 - Collection tracking and reminders

Legend: ✅ Operational | 🚧 In Development | 📋 Planned

Project Structure

slash-chain/
├── src/                        # Application source code
│   ├── SlashChain.API/        # ASP.NET Core Web API
│   ├── SlashChain.Infrastructure/  # EF Core, DbContext, migrations
│   ├── SlashChain.CLI/        # Terminal dashboard
│   ├── .claude/               # Agent scripts and slash commands
│   │   ├── agents/            # Agent bash scripts
│   │   └── commands/          # Slash command definitions
│   └── docker-compose.yml     # PostgreSQL setup
├── docs/                      # Comprehensive documentation
│   ├── AUTONOMOUS_VALUE_DELIVERY_SYSTEM.md  # System overview
│   ├── SUB_AGENT_ARCHITECTURE.md           # Agent design patterns
│   ├── GITHUB_REPOSITORY_PLAN.md           # Project management
│   ├── EPIC_ROADMAP.md                     # Development phases
│   ├── PROJECT_SUMMARY.md                  # Complete blueprint
│   ├── integrations/          # Integration guides
│   └── architecture/          # Technical specifications
├── tests/                     # Test suite
├── GETTING-STARTED.md         # Setup guide
└── README.md                  # This file

Development Roadmap

✅ Phase 1: Foundation (Weeks 1-4) - COMPLETE

ASP.NET Core API with engagement management
PostgreSQL database with EF Core migrations
Agent execution framework
Lead Agent with scoring algorithm
CLI dashboard
HubSpot integration

🚧 Phase 2: Sales Pipeline (Weeks 5-8) - IN PROGRESS

Opportunity Agent (strategic research and intake)
Strategic Intent Agent (discovery and documentation)
Enhanced HubSpot sync with deal stages
Agent chaining and workflow orchestration

📋 Phase 3: Planning Agents (Weeks 9-12)

Initiative Agent (decomposition and estimation)
Project Agent (charter and resource planning)
SOW Agent (pricing and document generation)
Contract management

📋 Phase 4: Delivery Agents (Weeks 13-16)

UX Agent (research and design)
Epic/Feature/Story Agents (work breakdown)
Task Agent (implementation tracking)
Delivery Agent (release management)

📋 Phase 5: Financial Agents (Weeks 17-20)

Acceptance Agent (UAT and sign-off)
Billing Agent (invoice generation)
Payment Agent (collection and reminders)
QuickBooks integration

📋 Phase 6: User Interfaces (Weeks 21-24)

Nuxt web application (dashboard, engagements, approvals)
Enhanced CLI with interactive approvals
Real-time updates via SignalR
Client portal

For complete roadmap, see docs/EPIC_ROADMAP.md.

Configuration

Operation Modes

Configure in .claude/settings.json:

{
  "slashChain": {
    "mode": "human-in-loop",
    "autoApproveThreshold": 0.8,
    "maxChainDepth": 10,
    "enableLearning": true
  }
}

Modes:

manual - Errors logged, requires manual intervention
human-in-loop (default) - Auto-starts workflows, pauses for approval on risky changes
auto - Fully automated (use with caution)

HubSpot Configuration

Configure in src/SlashChain.API/appsettings.json:

{
  "HubSpot": {
    "Enabled": true,
    "PrivateAppAccessToken": "your-token-here",
    "SyncIntervalSeconds": 300,
    "AutoTriggerLeadAgent": true
  }
}

See: docs/integrations/HUBSPOT_GETTING_STARTED.md for setup instructions.

Testing

Run the test suites:

# Test slash command infrastructure
./tests/test-chain-engine.sh

# Test HubSpot API integration
./tests/test-hubspot-integration.sh

# Or run both
./tests/test-chain-engine.sh && ./tests/test-hubspot-integration.sh

Tests cover:

Agent execution framework
State management and persistence
HubSpot API endpoints and integration
Database operations
Slash command configuration
API documentation validation

For comprehensive testing guide, see TESTING.md.

Documentation

GETTING-STARTED.md - Complete setup guide
docs/PROJECT_SUMMARY.md - System blueprint
docs/AUTONOMOUS_VALUE_DELIVERY_SYSTEM.md - Complete vision
docs/SUB_AGENT_ARCHITECTURE.md - Agent design patterns
docs/EPIC_ROADMAP.md - Development phases
docs/integrations/ - Integration guides

Troubleshooting

Database Connection Issues

# Check PostgreSQL is running
docker ps | grep postgres

# Verify connection
psql -h localhost -p 5433 -U slashchain -d slashchain

HubSpot Sync Not Working

# Test HubSpot API manually
curl https://api.hubapi.com/crm/v3/objects/contacts?limit=1 \
  -H "Authorization: Bearer your-token-here"

# Check API logs for errors

Agent Execution Fails

# Run agent with debug output
bash -x ./src/.claude/agents/lead-agent.sh <engagement-id>

# Check execution logs
psql -h localhost -p 5433 -U slashchain -d slashchain -c \
  "SELECT * FROM agent_executions ORDER BY started_at DESC LIMIT 1;"

For more troubleshooting help, see GETTING-STARTED.md#troubleshooting.

Contributing

Contributions welcome! Please:

Check existing issues and epics
Follow the established architecture patterns
Add tests for new functionality
Update documentation
Submit pull requests with clear descriptions

License

MIT

Support

GitHub Issues: https://github.com/DecoupledLogic/slash-chain/issues
Email: charleslbryant@decoupledlogic.com
Documentation: docs/

Built for the future of professional services - Autonomous, scalable, and intelligent. 🚀

Transform your entire professional services operation into a self-operating system. From lead to payment, let AI agents handle the process while you focus on strategy and client relationships.

Name		Name	Last commit message	Last commit date
Latest commit History 23 Commits
.claude		.claude
.github/ISSUE_TEMPLATE		.github/ISSUE_TEMPLATE
docs		docs
lib/utils		lib/utils
scripts		scripts
src		src
tests		tests
.env.example		.env.example
.gitignore		.gitignore
CLAUDE.md		CLAUDE.md
DEMO.md		DEMO.md
GETTING-STARTED.md		GETTING-STARTED.md
README.md		README.md
docker-compose.yml		docker-compose.yml
package-lock.json		package-lock.json
package.json		package.json

DecoupledLogic/slash-chain

Folders and files

Latest commit

History

Repository files navigation