🕸️ Agentic Mesh

Self-Optimizing Multi-Agent AI System on AWS

An AWS-native, serverless multi-agent orchestration framework that dynamically routes heterogeneous tasks to specialized AI agents — optimizing for cost, quality, and latency — with built-in verification, self-correction, and vector-cached memory.

Quick Start • Architecture • Features • Deployment • API • Dashboard • Roadmap

🎬 Demo

Submit any task → Intelligent routing → Specialized agents → Verified output → Cached for reuse

💡 The Problem

Most LLM-powered applications send every request to a single expensive model, regardless of task complexity. This leads to:

Issue	Impact
💸 Wasted spend	Simple summarization tasks hit GPT-4–class models
🐌 Unnecessary latency	Heavyweight models process lightweight tasks
🔁 Redundant computation	Identical tasks are reprocessed from scratch
❌ Silent failures	Bad outputs are returned without quality checks

🧠 The Solution

Agentic Mesh introduces a broker-worker-verifier architecture that:

1. Analyzes the task → understands type & complexity
2. Routes to the best agent → coding, research, or summarization
3. Verifies the output → LLM-as-a-Judge scores accuracy, completeness, relevance
4. Self-corrects failures → re-generates with a more capable model if quality < 7/10
5. Caches successes → embeds results in vector memory for future reuse

Result: Up to 60% cost reduction with higher reliability than single-model architectures.

✨ Key Features

Feature	Description
🧠 Intelligent Broker	Llama 3 8B analyzes task type & complexity in <100ms for pennies
🤖 Specialized Agents	Dedicated Coder, Researcher, and Summarizer agents with tuned prompts
🛡️ Bedrock Guardrails	PII anonymization, content filtering, and prompt injection protection
🔍 Shadow Verification	Every response is graded on accuracy, completeness, and relevance (1–10)
🔄 Self-Correction Loop	Failed outputs are automatically regenerated with enhanced prompts
🧬 Vector Memory	Titan Embeddings + OpenSearch cache solved tasks for instant reuse
📊 Cost Tracking	Per-invocation cost tracking with CloudWatch dashboards
📈 Observability	AWS X-Ray tracing, structured logging, and 6-widget CloudWatch dashboard
🖥️ Web Dashboard	Dark-mode glassmorphism UI with real-time pipeline visualization
🔐 Zero Servers	100% serverless — API Gateway, Lambda, Step Functions, SQS, DynamoDB

🏗️ Architecture

High-Level Overview

Mermaid Diagram

graph TD
    Client["🖥️ Client / Dashboard"]
    API["🌐 API Gateway"]
    SQS["📬 SQS Queue"]
    Orch["⚙️ Orchestrator Lambda"]
    SF["🔀 Step Functions"]
    Guard["🛡️ Guardrail Check"]
    Broker["🧠 Broker Agent<br/><small>Llama 3 8B</small>"]
    Cache["🧬 Vector Memory<br/><small>OpenSearch + Titan Embeddings</small>"]
    CacheHit{"Cache Hit?"}
    Route{"Route to Worker"}
    Coder["💻 Coder Agent<br/><small>Claude Sonnet 4.5</small>"]
    Researcher["🔍 Research Agent<br/><small>Claude Sonnet 4.5</small>"]
    Summarizer["📝 Summarizer Agent<br/><small>Claude Haiku 4.5</small>"]
    Verify["🔍 Verification Agent<br/><small>LLM-as-a-Judge</small>"]
    Check{"Quality ≥ 7/10?"}
    SelfCorrect["🔄 Self-Correction<br/><small>Escalate to Sonnet 4.5</small>"]
    Save["💾 Save Results"]
    DDB["🗄️ DynamoDB"]
    CW["📊 CloudWatch"]

    Client -->|POST /task| API
    API --> SQS
    SQS --> Orch
    Orch --> SF

    SF --> Guard
    Guard -->|Safe| Broker
    Guard -->|Blocked| Save

    Broker -.->|Embedding lookup| Cache
    Broker --> CacheHit
    CacheHit -->|Yes| Verify
    CacheHit -->|No| Route

    Route -->|coding| Coder
    Route -->|research| Researcher
    Route -->|summarize| Summarizer

    Coder --> Verify
    Researcher --> Verify
    Summarizer --> Verify

    Verify --> Check
    Check -->|Yes ✅| Save
    Check -->|No ❌| SelfCorrect
    SelfCorrect --> Save

    Save --> DDB
    Save -.->|Embed + Index| Cache
    Save -.->|Metrics| CW

    style Client fill:#6366f1,stroke:#4f46e5,color:#fff
    style Broker fill:#8b5cf6,stroke:#7c3aed,color:#fff
    style Coder fill:#a78bfa,stroke:#8b5cf6,color:#fff
    style Researcher fill:#818cf8,stroke:#6366f1,color:#fff
    style Summarizer fill:#c4b5fd,stroke:#a78bfa,color:#000
    style Verify fill:#22d3ee,stroke:#06b6d4,color:#000
    style SelfCorrect fill:#f43f5e,stroke:#e11d48,color:#fff
    style Cache fill:#34d399,stroke:#10b981,color:#000
    style Save fill:#fbbf24,stroke:#f59e0b,color:#000

🔄 System Workflow

Step-by-Step Pipeline

Client submits task
       │
       ▼
┌─────────────────┐
│  1. GUARDRAIL   │──── PII detected? → Anonymize & continue
│     CHECK       │──── Harmful content? → BLOCK task
└────────┬────────┘
         │ ✅ Safe
         ▼
┌─────────────────┐
│  2. BROKER      │──── Generate task embedding
│     AGENT       │──── Search vector cache (similarity ≥ 0.85)
│  (Llama 3 8B)   │──── Cache hit + quality ≥ 7? → Use cached answer
│                 │──── No cache → Predict type & complexity
└────────┬────────┘
         │
    ┌────┴────┬────────────┐
    ▼         ▼            ▼
┌────────┐ ┌──────────┐ ┌───────────┐
│ CODER  │ │RESEARCHER│ │SUMMARIZER │
│Sonnet  │ │ Sonnet   │ │  Haiku    │
│  4.5   │ │   4.5    │ │   4.5     │
└───┬────┘ └────┬─────┘ └─────┬─────┘
    └────────────┼─────────────┘
                 ▼
┌─────────────────┐
│ 4. VERIFICATION │──── Scores: Accuracy, Completeness, Relevance
│  (LLM-as-Judge) │──── Overall score ≥ 7/10 → ✅ PASS
│                 │──── Score < 7/10 → ❌ FAIL → Self-Correct
└────────┬────────┘
         │
    ┌────┴──── Score < 7?
    ▼                ▼
┌────────┐    ┌──────────────┐
│  PASS  │    │SELF-CORRECTION│
│        │    │ Re-generate   │
│        │    │ with enhanced │
│        │    │ prompt + more │
│        │    │ capable model │
└───┬────┘    └──────┬───────┘
    └────────────────┘
              │
              ▼
┌─────────────────┐
│  5. SAVE        │──── Store in DynamoDB
│     RESULTS     │──── Embed answer → Index in OpenSearch
│                 │──── Publish CloudWatch metrics
└─────────────────┘

🤖 Agent Architecture

Specialized Workers

Each agent is a Lambda function with a carefully tuned system prompt and model selection strategy:

Agent	Model	Specialty	When Chosen
💻 Coder	Claude Sonnet 4.5	Code generation, debugging, algorithms, reviews	`task_type == "coding"`
🔍 Researcher	Claude Sonnet 4.5	Analysis, comparison, explanations, concepts	`task_type == "research"`
📝 Summarizer	Claude Haiku 4.5	Condensing, key point extraction, reformatting	`task_type == "summarize"`
🧠 Broker	Llama 3 8B Instruct	Task classification & routing decisions	Every incoming task
🔍 Verifier	Claude Sonnet 4.5	Quality scoring across 3 dimensions	Every agent response

Complexity-Based Model Selection

The Coder agent uses adaptive model selection based on predicted complexity:

COMPLEXITY_MODELS = {
    "low":    "claude-sonnet",       # Sonnet 4.5 — fast, cost-efficient
    "medium": "claude-3.5-sonnet",   # Sonnet 4.5 — balanced
    "high":   "claude-3.5-sonnet",   # Sonnet 4.5 — maximum capability
}

Broker Routing Logic

                      ┌─────────────────────┐
                      │    Incoming Task     │
                      └──────────┬──────────┘
                                 │
                    ┌────────────▼────────────┐
                    │  1. Generate Embedding   │
                    │     (Titan V2)           │
                    └────────────┬────────────┘
                                 │
                    ┌────────────▼────────────┐
                    │  2. Search Vector Cache  │───── Similarity ≥ 0.85
                    │     (OpenSearch)         │      AND quality ≥ 7.0
                    └────┬──────────────┬─────┘        → Cache Hit!
                         │              │
                    No Cache       Cache Hit
                         │              │
              ┌──────────▼──────┐  ┌────▼────────────┐
              │ 3. LLM Predict  │  │ Return Cached    │
              │  Type+Complexity│  │ Answer + Agent   │
              │  (Llama 3 8B)  │  └──────────────────┘
              └──────────┬──────┘
                         │
              ┌──────────▼──────────┐
              │  Route to Worker:   │
              │  coding → Coder     │
              │  research → Rsrch   │
              │  summarize → Summ   │
              └─────────────────────┘

🧬 Vector Memory Architecture

Agentic Mesh maintains a semantic memory of all successfully completed tasks:

┌────────────────────────────────────────────────────────┐
│                   VECTOR MEMORY SYSTEM                  │
│                                                        │
│  ┌───────────┐   embed()   ┌──────────────────────┐   │
│  │ New Task  │────────────▶│  Amazon Titan         │   │
│  │ "Write    │             │  Embed Text V2        │   │
│  │  binary   │             │  (1024-dim vectors)   │   │
│  │  search"  │             └──────────┬───────────┘   │
│  └───────────┘                        │               │
│                                       ▼               │
│                          ┌────────────────────────┐   │
│                          │  OpenSearch Serverless  │   │
│                          │  ─────────────────────  │   │
│                          │  Cosine Similarity KNN  │   │
│                          │                        │   │
│                          │  Index: task-success-   │   │
│                          │         cache           │   │
│                          │                        │   │
│                          │  Fields:               │   │
│                          │  • task_text           │   │
│                          │  • task_embedding[]    │   │
│                          │  • answer              │   │
│                          │  • agent_used          │   │
│                          │  • quality_score       │   │
│                          │  • model_used          │   │
│                          │  • timestamp           │   │
│                          └────────────────────────┘   │
│                                                        │
│  Threshold: similarity ≥ 0.85 AND quality ≥ 7.0       │
│  Result: Skip worker + verification → instant answer   │
└────────────────────────────────────────────────────────┘

Benefits:

🚀 Instant responses for previously-solved tasks (~0ms worker latency)
💰 Zero LLM cost on cache hits
📈 Improving over time — the more tasks processed, the higher the hit rate

💰 Cost Optimization Strategy

Agentic Mesh employs a multi-layered cost optimization approach:

Layer	Strategy	Savings
1. Smart Routing	Llama 3 8B (~$0.0003/call) routes instead of sending everything to Sonnet	~70% on routing
2. Model Tiering	Haiku 4.5 for summarization vs Sonnet 4.5 for coding	~60% per task
3. Complexity Matching	Low-complexity coding tasks use lighter models	~30% per task
4. Vector Cache	Identical/similar tasks return cached results instantly	100% on hits
5. Guardrail Blocking	Harmful tasks are blocked before reaching any model	100% on blocked

Per-Model Pricing (per 1K tokens)

Model	Input	Output	Use Case
Llama 3 8B Instruct	$0.0003	$0.0006	Broker routing decisions
Claude Haiku 4.5	$0.0010	$0.0050	Summarization tasks
Claude Sonnet 4.5	$0.0030	$0.0150	Coding, research, verification
Titan Embed Text V2	$0.0002	—	Task embeddings

📊 Observability Dashboard

CloudWatch Dashboard (6 Widgets)

The system ships with a pre-built CloudWatch dashboard:

Widget	Metrics
📈 Routing Distribution	Tasks per agent (coder/researcher/summarizer)
💰 Cost per Agent	Running cost breakdown by agent type
⚡ Latency by Agent	p50/p95 latency for each worker
✅ Verification Scores	Quality score distribution over time
🧠 Cache Hit Rate	Percentage of tasks served from vector memory
🔄 Escalation Rate	How often self-correction is triggered

Web Dashboard

A premium glassmorphism dark-mode dashboard is included:

python -m http.server 8080 --directory dashboard
# Open http://localhost:8080

Features:

💬 Chat-like task submission interface
🔀 Animated Step Functions pipeline visualization
📊 Real-time analytics (agent performance, quality rings, cost breakdown)
📋 Filterable task history with detail modals
🔔 Toast notifications for task events

🚀 Quick Start

Prerequisites

Requirement	Version
Python	3.10+
AWS CLI	2.x (configured with credentials)
AWS SAM CLI	1.x
AWS Account	With Bedrock model access enabled

Enable Bedrock Models

Before deploying, enable the following models in the AWS Bedrock Console:

✅ Meta Llama 3 8B Instruct
✅ Anthropic Claude Haiku 4.5
✅ Anthropic Claude Sonnet 4.5
✅ Amazon Titan Embed Text V2

📦 Deployment

Step 1: Clone the Repository

git clone https://github.com/yourusername/agentic-mesh.git
cd agentic-mesh

Step 2: Install Dependencies

pip install -r requirements.txt

Step 3: Build with SAM

sam build

Step 4: Deploy to AWS

# Guided deployment (first time)
sam deploy --guided

# Subsequent deployments
sam deploy --no-confirm-changeset

SAM will provision all resources:

API Gateway (REST)
10 Lambda Functions
Step Functions State Machine
SQS Queue
DynamoDB Table
OpenSearch Serverless Collection
CloudWatch Dashboard
IAM Roles & Policies
Bedrock Guardrail

Step 5: Note Your API Endpoint

After deployment, SAM outputs your API URL:

Key                 ApiEndpoint
Description         API Gateway endpoint URL
Value               https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/Prod/task

📡 API Reference

Submit a Task

POST /task
Content-Type: application/json

{
  "task": "Write a Python function for binary search with error handling",
  "type_hint": "coding"   // Optional: "coding" | "research" | "summarize" | "auto"
}

Response:

{
  "task_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "QUEUED",
  "message": "Task submitted successfully"
}

Get Task Result

GET /task/{task_id}

Response (completed):

{
  "task_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "SUCCESS",
  "task": "Write a Python function for binary search with error handling",
  "answer": "def binary_search(arr, target):\n    if not arr:\n        raise ValueError('Array cannot be empty')\n    ...",
  "agent": "coder",
  "model": "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
  "quality_score": 8.5,
  "cost_estimate": 0.0042,
  "worker_latency_ms": 3200,
  "cache_hit": false,
  "escalated": false
}

Example cURL Commands

# Submit a coding task
curl -X POST https://YOUR_API/Prod/task \
  -H "Content-Type: application/json" \
  -d '{"task": "Write a Python function for binary search", "type_hint": "coding"}'

# Submit a research task
curl -X POST https://YOUR_API/Prod/task \
  -H "Content-Type: application/json" \
  -d '{"task": "Explain the differences between REST and GraphQL"}'

# Submit a summarization task
curl -X POST https://YOUR_API/Prod/task \
  -H "Content-Type: application/json" \
  -d '{"task": "Summarize the key principles of clean code", "type_hint": "summarize"}'

# Get result (poll until status != QUEUED)
curl https://YOUR_API/Prod/task/a1b2c3d4-e5f6-7890-abcd-ef1234567890

PowerShell Examples

# Submit task
$response = Invoke-RestMethod -Uri "https://YOUR_API/Prod/task" `
  -Method POST -ContentType "application/json" `
  -Body '{"task": "Write a merge sort in Python"}'

# Get result
$result = Invoke-RestMethod -Uri "https://YOUR_API/Prod/task/$($response.task_id)"
$result.answer

🧪 Local Development

Setup

# Clone and install
git clone https://github.com/yourusername/agentic-mesh.git
cd agentic-mesh
pip install -r requirements.txt

# Run tests
pytest tests/ -v

# Run specific test suite
pytest tests/test_cost_tracker.py -v
pytest tests/test_guardrails.py -v

Run the Dashboard Locally

python -m http.server 8080 --directory dashboard

Open http://localhost:8080 in your browser.

Invoke Functions Locally (SAM)

# Invoke a single function with a test event
sam local invoke GuardrailFunction --event events/guardrail_test.json

# Start local API for testing
sam local start-api

📁 Project Structure

agentic-mesh/
├── 📄 template.yaml                  # SAM infrastructure-as-code (all AWS resources)
├── 📄 samconfig.toml                 # SAM deployment configuration
├── 📄 requirements.txt               # Python dependencies
├── 📄 pyproject.toml                 # Project metadata
│
├── 📂 src/
│   ├── 📂 handlers/                  # Lambda function handlers
│   │   ├── api_handler.py            #   REST API (POST /task, GET /task/{id})
│   │   ├── orchestrator.py           #   SQS → Step Functions trigger
│   │   ├── broker.py                 #   🧠 Broker Agent (routing decisions)
│   │   ├── guardrail_handler.py      #   🛡️ Bedrock Guardrail check
│   │   ├── worker_coder.py           #   💻 Coding specialist
│   │   ├── worker_researcher.py      #   🔍 Research specialist
│   │   ├── worker_summarizer.py      #   📝 Summarization specialist
│   │   ├── verification_agent.py     #   🔍 LLM-as-a-Judge quality scoring
│   │   ├── self_correction.py        #   🔄 Re-generation with enhanced prompts
│   │   └── save_results.py           #   💾 DynamoDB + Vector cache persistence
│   │
│   ├── 📂 models/                    # Shared model clients
│   │   ├── bedrock_client.py         #   Unified Bedrock invocation (Claude, Llama, Titan)
│   │   ├── cost_tracker.py           #   Per-model cost calculation + CloudWatch metrics
│   │   └── vector_memory.py          #   OpenSearch Serverless KNN search & indexing
│   │
│   ├── 📂 guardrails/               # Guardrail configurations
│   ├── 📂 observability/            # CloudWatch dashboard definitions
│   └── 📂 state_machine/            # Step Functions ASL definition
│       └── definition.asl.json       #   Full state machine (13 states)
│
├── 📂 dashboard/                     # Web Dashboard UI
│   ├── index.html                    #   Main page
│   ├── css/style.css                 #   Glassmorphism dark theme
│   └── js/app.js                     #   API integration + real-time polling
│
├── 📂 tests/                         # Test suite
│   ├── test_cost_tracker.py          #   Cost calculation + model tier tests
│   └── test_guardrails.py            #   Guardrail behavior tests
│
└── 📂 events/                        # Sample Lambda invocation events

📈 Monitoring with CloudWatch

Pre-Built Dashboard

The deployment automatically creates a CloudWatch dashboard at:

https://us-east-1.console.aws.amazon.com/cloudwatch/home?region=us-east-1#dashboards:name=AgenticMeshDashboard

Custom Metrics Published

Metric Namespace	Metric Name	Dimensions
`AgenticMesh`	`TaskRouted`	`Agent`, `CacheHit`
`AgenticMesh`	`TaskCost`	`Agent`, `Model`
`AgenticMesh`	`WorkerLatency`	`Agent`
`AgenticMesh`	`VerificationScore`	`Agent`
`AgenticMesh`	`EscalationTriggered`	`OriginalAgent`
`AgenticMesh`	`CacheHitRate`	—

X-Ray Tracing

All Lambda functions are instrumented with AWS X-Ray through Powertools:

from aws_lambda_powertools import Tracer
tracer = Tracer(service="agentic-mesh")

@tracer.capture_lambda_handler
def lambda_handler(event, context):
    ...

🛡️ Security & Guardrails

Bedrock Guardrails

Protection	Description
PII Anonymization	Automatically detects and masks personal data (names, emails, SSNs)
Content Filtering	Blocks harmful, toxic, or inappropriate content
Prompt Injection	Detects and neutralizes prompt injection attempts
Topic Blocking	Configurable topic deny-lists

Infrastructure Security

Measure	Implementation
Least Privilege IAM	Each Lambda has scoped-down permissions
Encryption at Rest	DynamoDB + OpenSearch use AWS-managed keys
Encryption in Transit	All API calls use HTTPS/TLS 1.2+
VPC Isolation	OpenSearch Serverless runs in managed VPC
CORS Protection	API Gateway configured with explicit allow-origins
Input Validation	Request body validation before processing

⚡ Performance & Scalability

Metric	Value
Cold Start	~2-3s (Lambda with Powertools)
Warm Latency	~8-15s end-to-end (including LLM inference)
Cache Hit Latency	<1s (skip worker + verification)
Concurrent Tasks	Limited by Lambda concurrency (default 1000)
SQS Throughput	Up to 3,000 messages/second
DynamoDB	On-demand capacity — auto-scales to any load
OpenSearch	Serverless — auto-scales compute and storage

Scalability Characteristics

Load Increases → Lambdas scale horizontally (auto)
                → SQS absorbs burst traffic
                → DynamoDB on-demand scales
                → OpenSearch Serverless scales
                → No provisioned capacity to manage
                → Zero operational overhead

📊 Benchmarks

Task Type	Model	Avg Latency	Avg Cost	Quality Score
Coding (simple)	Claude Sonnet 4.5	~5s	$0.003	8.2/10
Coding (complex)	Claude Sonnet 4.5	~12s	$0.008	7.8/10
Research	Claude Sonnet 4.5	~8s	$0.005	8.5/10
Summarization	Claude Haiku 4.5	~3s	$0.001	8.0/10
Cache Hit	—	<100ms	$0.000	≥7.0/10
Broker Routing	Llama 3 8B	<1s	$0.0003	—

Benchmarks measured on us-east-1 with warm Lambda invocations. Your results may vary.

🏛️ Architecture Decision Records

Decision	Choice	Rationale
Orchestration	Step Functions over SQS choreography	Visual debugging, built-in retry/catch, state management
Broker Model	Llama 3 8B over Claude Haiku	10x cheaper for routing — accuracy is sufficient for classification
Vector Store	OpenSearch Serverless over Pinecone	AWS-native, no external dependencies, serverless scaling
Queue	SQS over EventBridge	Simple FIFO semantics, built-in DLQ, SAM integration
Verification	LLM-as-a-Judge over heuristics	Generalizes across task types, provides natural-language feedback
Self-Correction	Single retry with escalation	Prevents infinite loops while improving quality
IaC	SAM over CDK/Terraform	Native Lambda support, simpler syntax, faster iterations
Dashboard	Vanilla HTML/CSS/JS over React	Zero build step, no node_modules, instant deployment to S3

🗺️ Roadmap

🤝 Contributing

Contributions are welcome and greatly appreciated! Here's how to get started:

Development Workflow

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Write your code following the existing patterns
Test your changes: pytest tests/ -v
Build with SAM: sam build
Commit with a descriptive message: git commit -m "feat: add amazing feature"
Push to your branch: git push origin feature/amazing-feature
Open a Pull Request

Code Style

Follow PEP 8 for Python code
Use type hints where possible
Add docstrings to all functions
Include structured logging with aws_lambda_powertools.Logger
Add @tracer.capture_lambda_handler to all Lambda handlers

Areas We Need Help With

Area	Difficulty	Impact
🧪 More test coverage	Easy	High
📖 Documentation improvements	Easy	Medium
🔌 New worker agents (e.g., SQL, DevOps)	Medium	High
🌐 WebSocket streaming	Medium	High
📎 Multi-modal support	Hard	High
🔗 Agent collaboration chains	Hard	Very High

📄 License

This project is licensed under the MIT License — see the LICENSE file for details.

MIT License

Copyright (c) 2026 Agentic Mesh Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

🙏 Acknowledgments

AWS Bedrock — Foundation model hosting
AWS Lambda Powertools — Structured logging, tracing, and event handling
OpenSearch — Vector similarity search
Anthropic Claude — AI models powering the agents
Meta Llama — Lightweight broker model

🌟 Star History

If you find this project useful, please consider giving it a ⭐ — it helps others discover the project!

Built with 🧠 by the Agentic Mesh community

Back to Top ↑

Name		Name	Last commit message	Last commit date
Latest commit History 14 Commits
.aws-sam		.aws-sam
.devcontainer		.devcontainer
.github		.github
.vscode		.vscode
articles		articles
dashboard		dashboard
events		events
src		src
tests		tests
.editorconfig		.editorconfig
.gitignore		.gitignore
.python-version		.python-version
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
SECURITY.md		SECURITY.md
main.py		main.py
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt
samconfig.toml		samconfig.toml
template.yaml		template.yaml

Folders and files

Latest commit

History

Repository files navigation

🕸️ Agentic Mesh

🎬 Demo

💡 The Problem

🧠 The Solution

✨ Key Features

🏗️ Architecture

High-Level Overview

Mermaid Diagram

🔄 System Workflow

Step-by-Step Pipeline

🤖 Agent Architecture

Specialized Workers

Complexity-Based Model Selection

Broker Routing Logic

🧬 Vector Memory Architecture

💰 Cost Optimization Strategy

Per-Model Pricing (per 1K tokens)

📊 Observability Dashboard

CloudWatch Dashboard (6 Widgets)

Web Dashboard

🚀 Quick Start

Prerequisites

Enable Bedrock Models

📦 Deployment

Step 1: Clone the Repository

Step 2: Install Dependencies

Step 3: Build with SAM

Step 4: Deploy to AWS

Step 5: Note Your API Endpoint

📡 API Reference

Submit a Task

Get Task Result

Example cURL Commands

PowerShell Examples

🧪 Local Development

Setup

Run the Dashboard Locally

Invoke Functions Locally (SAM)

📁 Project Structure

📈 Monitoring with CloudWatch

Pre-Built Dashboard

Custom Metrics Published

X-Ray Tracing

🛡️ Security & Guardrails

Bedrock Guardrails

Infrastructure Security

⚡ Performance & Scalability

Scalability Characteristics

📊 Benchmarks

🏛️ Architecture Decision Records

🗺️ Roadmap

🤝 Contributing

Development Workflow

Code Style

Areas We Need Help With

📄 License

🙏 Acknowledgments

🌟 Star History

About

Topics

Resources

License

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages