Build, orchestrate, and govern AI agents at scale with native MCP support, streaming capabilities, and production-ready testing infrastructure.
- Overview
- Key Features
- Quick Start
- Installation
- Usage Examples
- Architecture
- Documentation
- Testing
- Project Structure
- Development
- Contributing
- License
AgentOSX is a modular, production-ready framework for building intelligent AI agents with native Model Context Protocol (MCP) support. Whether you're creating simple task automation, complex multi-agent orchestration, or production-grade AI systems, AgentOSX provides the foundation you need.
- 🔌 MCP-Native: First-class support for Model Context Protocol - expose agents as MCP servers or consume external MCP tools
- 🎭 Multi-Agent Orchestration: Three powerful patterns (Swarm, CrewAI, LangGraph) for coordinating multiple agents
- ⚡ Production-Ready: Comprehensive testing (23/23 passing), state management, error handling, and observability
- 🛠️ Developer-Friendly: Rich CLI, hot reload, interactive playground, and extensive examples
- 📊 Streaming-First: Real-time streaming support with SSE, WebSocket, and token-by-token responses
- 🏗️ Extensible: Plugin architecture with declarative YAML manifests for agent configuration
- MCP Protocol Integration: Full JSON-RPC 2.0 implementation with tool, resource, and prompt support
- Agent Lifecycle Management: Comprehensive hooks (
on_init,on_start,on_stop) with state management - Dynamic Tool System: Auto-registration, schema inference, sync/async support with ToolAdapter
- Multiple Transport Layers: STDIO, SSE, WebSocket transports for flexible communication
- State Persistence: Checkpointing, versioning, rollback, and context management
- LLM Router: Support for 7+ providers (OpenAI, Anthropic, Gemini, Grok, OpenRouter, Together, Ollama)
- Streaming Support: Token-by-token streaming with multiple event types and SSE format
- Swarm-Style Handoffs: Lightweight agent-to-agent delegation with context preservation
- CrewAI-Style Teams: Role-based collaboration with 4 roles and 3 execution modes
- LangGraph-Style Workflows: DAG execution with 6 node types and conditional branching
- Event-Driven Coordination: Message bus with pub/sub pattern and priority queuing
- Central Coordinator: Registry, discovery, and lifecycle management for agent ecosystems
- Advanced Features: Parallel execution, error handlers, retry logic, checkpointing
- Rich CLI: 9 commands for agent management (
init,run,dev,playground,mcp) - Hot Reload: Automatic agent reloading during development with file watching
- Interactive Playground: REPL interface for testing agents with command history
- Comprehensive Testing: pytest integration, 23/23 tests passing, example test suite
- Documentation: 800+ lines of guides (getting started, testing, architecture, API reference)
- Production Examples: Calculator, weather, streaming chat, MCP server integration
- Python 3.10 or higher
- pip (Python package manager)
- Virtual environment (recommended)
# Clone the repository
git clone https://github.com/theagentic/agentOSX.git
cd agentOSX
# Create virtual environment
python -m venv venv
# Activate virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate
# Install dependencies
pip install -r requirements.txt
# Install for development (optional)
pip install -e .# Create a new agent from template
agentosx init my-first-agent
# Run your agent
agentosx run my-first-agent --input="Hello, AgentOSX!"
# Start development server with hot reload
agentosx dev my-first-agent --watch
# Test interactively in playground
agentosx playground --agent=my-first-agent
# Run as MCP server
agentosx mcp start my-first-agent --transport=stdiofrom agentosx.agents.base import BaseAgent
class SimpleAgent(BaseAgent):
def __init__(self):
super().__init__(name="simple-agent", version="1.0.0")
async def process(self, input: str, context=None) -> str:
"""Process user input and return a response."""
return f"You said: {input}"
# Run your agent
async def main():
agent = SimpleAgent()
await agent.initialize()
await agent.start()
result = await agent.process("Hello!")
print(result) # Output: You said: Hello!
await agent.stop()
# Execute
import asyncio
asyncio.run(main())Create agents/my_agent/agent.yaml:
persona:
name: "Research Assistant"
system_prompt: "You are an expert researcher"
llm:
primary:
provider: "anthropic"
model: "claude-3-sonnet"
temperature: 0.7
tools:
- name: "search_web"
schema:
type: "object"
properties:
query: {type: "string"}
implementation: "tools.search_tool"
workflows:
- name: "research_flow"
type: "graph"
nodes:
- {id: "start", type: "start"}
- {id: "research", type: "agent"}
- {id: "end", type: "end"}
mcp:
server:
resources:
- uri: "agent://results"Load and run:
from agentosx.agents.loader import AgentLoader
# Load from manifest
loader = AgentLoader()
agent = await loader.load_from_yaml("agents/my_agent/agent.yaml")
# Run agent
await agent.initialize()
result = await agent.process("Find information about AI")
print(result)from agentosx.agents.base import BaseAgent
class CalculatorAgent(BaseAgent):
def __init__(self):
super().__init__(name="calculator", version="1.0.0")
async def process(self, input: str, context=None) -> str:
"""Evaluate mathematical expressions."""
try:
result = eval(input) # Note: Use safe eval in production
return f"Result: {result}"
except Exception as e:
return f"Error: {str(e)}"
# Test it
agent = CalculatorAgent()
await agent.initialize()
await agent.start()
result = await agent.process("10 + 5 * 2")
print(result) # Output: Result: 20from agentosx.tools import ToolAdapter
class WeatherAgent(BaseAgent):
def __init__(self):
super().__init__(name="weather", version="1.0.0")
self.tool_adapter = ToolAdapter()
# Register custom tool
self.tool_adapter.register_tool(
name="get_weather",
description="Get weather for a city",
func=self.get_weather
)
async def get_weather(self, city: str) -> dict:
"""Fetch weather data."""
# Mock data - replace with real API
return {"city": city, "temp": 72, "condition": "Sunny"}
async def process(self, input: str, context=None) -> str:
weather = await self.get_weather(input)
return f"{weather['city']}: {weather['temp']}°F, {weather['condition']}"from agentosx.streaming.events import TextEvent, EventType
class StreamingChatAgent(BaseAgent):
async def stream(self, input: str, context=None):
"""Stream response token by token."""
response = f"Echo: {input}"
words = response.split()
for i, word in enumerate(words):
is_complete = (i == len(words) - 1)
yield TextEvent(
text=word + " ",
agent_id=self.name,
is_complete=is_complete
)
# Use streaming
agent = StreamingChatAgent()
async for event in agent.stream("Hello world"):
print(event.text, end="") # Output: Echo: Hello worldfrom agentosx.orchestration import Coordinator, HandoffManager, Crew, WorkflowGraph
# Setup coordinator
coordinator = Coordinator()
await coordinator.register_agent("research", research_agent)
await coordinator.register_agent("writer", writer_agent)
# Option 1: Swarm-style handoffs
handoff_manager = HandoffManager(coordinator)
result = await handoff_manager.handoff(
from_agent_id="research",
to_agent_id="writer",
input="Write about AI trends"
)
# Option 2: CrewAI-style teams
crew = Crew(name="content-crew")
await crew.add_member("research", research_agent, CrewRole.WORKER)
await crew.add_member("writer", writer_agent, CrewRole.WORKER)
await crew.add_task("Create article about AI")
results = await crew.execute()
# Option 3: LangGraph-style workflows
workflow = WorkflowGraph("pipeline", coordinator)
workflow.add_node("research", NodeType.AGENT, agent_id="research")
workflow.add_node("write", NodeType.AGENT, agent_id="writer")
workflow.add_edge("research", "write")
state = await workflow.execute(input="AI trends 2025")# Convert any agent to an MCP server
from agentosx.mcp import MCPServer
agent = CalculatorAgent()
mcp_server = agent.to_mcp_server()
# List available tools
tools = mcp_server.list_tools()
print(f"Available tools: {[t.name for t in tools]}")
# Start MCP server with STDIO transport
await mcp_server.start(transport="stdio")- QUICKSTART.md - Step-by-step guide for beginners
- docs/getting-started.md - Detailed setup and first agent
- docs/testing-guide.md - Complete testing documentation (800+ lines)
- docs/architecture.md - System architecture and design patterns
- AGENT_MANIFEST_GUIDE.md - YAML manifest specification (274 lines)
- API_REFERENCE.md - Complete API documentation
- docs/agent-development.md - Creating custom agents
- CLI_REFERENCE.md - CLI command reference
- AGENTOS_INTEGRATION_QUICKREF.md - AgentOS integration guide
- PHASE1_COMPLETE.md - MCP foundation implementation
- PHASE2_COMPLETE.md - Multi-agent orchestration
- PHASE3_COMPLETE.md - Developer experience features
- PHASE4_COMPLETE.md - Production readiness
- PLAN.md - Project roadmap and milestones
- PRD.md - Product requirements document
- RELEASE_SUMMARY.md - v0.1.0 release notes
AgentOSX comes with comprehensive testing infrastructure and examples:
# Run all tests
pytest tests/
# Run with coverage
pytest --cov=agentosx --cov-report=html
# Run specific test file
pytest tests/test_integration.py -v
# Run specific test
pytest tests/test_examples.py::test_simple_calculator_agent -v✅ Integration Tests: 13/13 passing (100%)
✅ Example Tests: 10/10 passing (100%)
✅ Total: 23/23 tests passing (100%)
⚡ Runtime: ~1 second for full suite
import pytest
from agentosx import BaseAgent, AgentStatus
@pytest.mark.asyncio
async def test_my_agent():
agent = MyAgent()
await agent.initialize()
await agent.start()
# Test agent status
assert agent.state.status == AgentStatus.RUNNING
# Test processing
result = await agent.process("test input")
assert "expected" in result
# Test cleanup
await agent.stop()
assert agent.state.status == AgentStatus.STOPPEDSee docs/testing-guide.md for complete testing documentation.
┌─────────────────────────────────────────────────────────────┐
│ CLI Layer │
│ (init, run, dev, playground, mcp commands) │
└──────────────────────┬──────────────────────────────────────┘
│
┌──────────────────────┴──────────────────────────────────────┐
│ Orchestration Layer │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Swarm │ │ CrewAI │ │ LangGraph │ │
│ │ Handoffs │ │ Teams │ │ Workflows │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ Coordinator + Message Bus │
└──────────────────────┬──────────────────────────────────────┘
│
┌──────────────────────┴──────────────────────────────────────┐
│ Agent Layer │
│ ┌────────────────────────────────────────────────┐ │
│ │ BaseAgent (Lifecycle, State, Tools, MCP) │ │
│ └────────────────────────────────────────────────┘ │
│ ↓ ↓ ↓ │
│ [Twitter Agent] [Blog Agent] [Custom Agents] │
└──────────────────────┬──────────────────────────────────────┘
│
┌──────────────────────┴──────────────────────────────────────┐
│ Foundation Layer │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ MCP │ │ Streaming│ │ Tools │ │ Memory │ │
│ │ Protocol │ │ Events │ │ Adapter │ │ Store │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ LLM │ │ Policy │ │Transport │ │ State │ │
│ │ Router │ │ Engine │ │ Layer │ │ Manager │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────────┘
- Protocol Implementation: Full JSON-RPC 2.0 with request/response/notification
- Server Mode: Expose agent capabilities as tools, resources, and prompts
- Client Mode: Consume external MCP servers (filesystem, git, databases)
- Transport Layers: STDIO, SSE, WebSocket for flexible communication
- Dynamic Discovery: Automatic tool registration and schema inference
Initialize → Start → Process → Stop
↓ ↓ ↓ ↓
on_init() on_start() async on_stop()
process()
- State Management: Status tracking, context preservation, checkpointing
- Hooks: Lifecycle callbacks for initialization, startup, and shutdown
- Error Handling: Graceful degradation and recovery mechanisms
Three powerful patterns for different use cases:
Swarm-Style Handoffs (Lightweight Delegation)
- Agent-to-agent task delegation
- Context preservation across handoffs
- Return-to-caller mechanism
- Auto-routing with custom rules
CrewAI-Style Teams (Role-Based Collaboration)
- 4 roles: Manager, Worker, Reviewer, Specialist
- Task queue with priorities
- 3 execution modes: Sequential, Parallel, Hierarchical
- Shared memory for team state
LangGraph-Style Workflows (DAG Execution)
- 6 node types: Agent, Condition, Checkpoint, Parallel, Error Handler, Start/End
- 4 edge conditions: Always, On Success, On Failure, Conditional
- State management with checkpointing
- Retry logic and error handling
- Event-driven coordination with pub/sub pattern
- Topic-based routing with wildcards (
agent.*,tool.execute.*) - Priority queuing (LOW, NORMAL, HIGH, CRITICAL)
- Handler statistics and message history
- Dynamic registration with schema inference
- Sync and async tool support
- MCP-compatible tool definitions
- Built-in tools: search, file operations, API calls
- Token-by-token streaming responses
- Multiple event types (LLM_TOKEN, TOOL_CALL, STATE_CHANGE)
- SSE and WebSocket support
- Backpressure handling
agentOSX/
├── agentosx/ # Core framework package
│ ├── agents/ # Agent foundation
│ │ ├── base.py # BaseAgent class with lifecycle
│ │ ├── decorators.py # Agent decorators (@agent, @tool)
│ │ ├── lifecycle.py # Lifecycle management
│ │ ├── loader.py # YAML manifest loader
│ │ └── state.py # State management
│ │
│ ├── orchestration/ # Multi-agent orchestration
│ │ ├── coordinator.py # Central coordinator (265 lines)
│ │ ├── handoff.py # Swarm-style handoffs (347 lines)
│ │ ├── crew.py # CrewAI teams (456 lines)
│ │ ├── graph.py # LangGraph workflows (546 lines)
│ │ └── message_bus.py # Event bus (359 lines)
│ │
│ ├── mcp/ # Model Context Protocol
│ │ ├── protocol.py # JSON-RPC 2.0 implementation
│ │ ├── server.py # MCP server with tools/resources
│ │ ├── client.py # MCP client for external servers
│ │ ├── transport/ # STDIO, SSE, WebSocket transports
│ │ ├── tools/ # Tool definitions and adapters
│ │ ├── resources/ # Resource providers
│ │ └── prompts/ # Prompt templates
│ │
│ ├── streaming/ # Real-time streaming
│ │ ├── events.py # Event types (TextEvent, etc.)
│ │ ├── sse.py # Server-Sent Events
│ │ └── websocket.py # WebSocket streaming
│ │
│ ├── tools/ # Tool adapter system
│ │ ├── adapter.py # ToolAdapter for registration
│ │ ├── definitions.py # Tool schema definitions
│ │ └── builtin/ # Built-in tools
│ │
│ ├── cli/ # Command-line interface
│ │ ├── main.py # CLI entry point
│ │ ├── commands/ # CLI command implementations
│ │ └── utils.py # CLI utilities
│ │
│ ├── dev/ # Development tools
│ │ ├── hot_reload.py # Hot reload functionality
│ │ └── playground.py # Interactive playground
│ │
│ ├── sdk/ # SDK and builders
│ │ ├── builder.py # Fluent builder API
│ │ ├── types.py # Type definitions
│ │ └── utilities.py # Helper utilities
│ │
│ ├── evaluation/ # Testing and evaluation
│ │ ├── harness.py # Test harness
│ │ └── metrics.py # Evaluation metrics
│ │
│ ├── marketplace/ # Agent marketplace
│ │ ├── registry.py # Agent registry
│ │ ├── installer.py # Agent installer
│ │ ├── publisher.py # Publishing tools
│ │ └── versioning.py # Version management
│ │
│ └── integrations/ # External integrations
│ └── agentos/ # AgentOS compatibility
│
├── agents/ # Agent implementations
│ ├── _template/ # Agent template (584 lines)
│ │ ├── agent.yaml # Template manifest
│ │ ├── agent.py # Template implementation
│ │ └── README.md # Template guide
│ │
│ ├── twitter_agent/ # Twitter bot agent
│ │ ├── agent.yaml # Manifest (330 lines)
│ │ ├── agent.py # Implementation (484 lines)
│ │ └── .env.example # Environment template
│ │
│ ├── blog_agent/ # Blog automation agent
│ │ ├── agent.yaml # Manifest (447 lines)
│ │ ├── agent.py # Implementation
│ │ └── README.md # Usage guide
│ │
│ └── social_poster/ # Social media poster
│ ├── agent.yaml # Configuration
│ └── agent.py # Implementation
│
├── core/ # Core utilities (legacy)
│ ├── llm/ # LLM abstraction layer
│ ├── memory/ # Memory systems
│ ├── policy/ # Governance policies
│ └── tools/ # Tool utilities
│
├── tests/ # Test suite
│ ├── test_integration.py # Integration tests (13 tests)
│ ├── test_examples.py # Example tests (10 tests)
│ ├── unit/ # Unit tests
│ └── fixtures/ # Test fixtures
│
├── examples/ # Usage examples
│ ├── quickstart/ # Quickstart examples
│ ├── complete_example.py # Complete agent example
│ ├── mcp_server_example.py # MCP server example
│ ├── orchestration_examples.py # Multi-agent examples
│ └── social_post_demo.py # Social media demo
│
├── docs/ # Documentation
│ ├── getting-started.md # Getting started guide
│ ├── architecture.md # Architecture overview
│ ├── agent-development.md # Agent development guide
│ └── testing-guide.md # Testing documentation (800+ lines)
│
├── .gitignore # Git ignore patterns
├── requirements.txt # Python dependencies
├── pyproject.toml # Python project config
├── pytest.ini # Pytest configuration
├── README.md # This file
└── LICENSE # MIT License
All examples are located in the examples/ directory and are production-ready:
Complete example showing all AgentOSX features:
- Custom tool registration
- State management
- Error handling
- Lifecycle hooks
Convert any agent to an MCP server:
- Tool exposure via MCP
- Resource management
- STDIO/SSE/WebSocket transports
Comprehensive demonstration of all three orchestration patterns:
- Example 1: Swarm-style handoffs with context preservation
- Example 2: CrewAI-style teams with role-based collaboration
- Example 3: LangGraph-style workflows with DAG execution
- Example 4: Message bus coordination with pub/sub
- Example 5: Combined orchestration using multiple patterns
Real-world social media automation with approval workflow
Full-featured Twitter bot with AI integration:
- ✅ Tweepy v2 API integration
- ✅ Google Gemini for AI-generated threads
- ✅ File system monitoring for blog posts
- ✅ 9-node workflow with approval gate
- ✅ Rate limiting and statistics tracking
- ✅ OAuth2 authentication
- 814 lines of production code
Sophisticated blog content generation:
- ✅ Complex 15-node workflow
- ✅ Parallel section writing
- ✅ Quality check with conditional looping
- ✅ Manual approval gate
- ✅ Plagiarism detection
- ✅ Multi-format output (Markdown, HTML, PDF)
- Manifest complete (447 lines)
Multi-platform social media posting agent
AgentOSX provides multiple ways to create agents:
# Create from template
agentosx init my-awesome-agent
# Navigate to agent directory
cd agents/my-awesome-agent
# Edit agent.yaml and agent.py
# See agents/_template/ for reference# Copy the template directory
cp -r agents/_template agents/my-awesome-agent
# Customize the files
cd agents/my-awesome-agent# Create agent.py
from agentosx.agents.base import BaseAgent
class MyAwesomeAgent(BaseAgent):
def __init__(self):
super().__init__(name="my-awesome-agent", version="1.0.0")
async def on_init(self):
"""Called once during initialization."""
print("Agent initializing...")
async def on_start(self):
"""Called when agent starts."""
print("Agent started!")
async def process(self, input: str, context=None) -> str:
"""Main processing logic."""
return f"Processed: {input}"
async def on_stop(self):
"""Called when agent stops."""
print("Agent stopped!")# Run all tests
pytest tests/
# Run specific test file
pytest tests/test_integration.py -v
# Run with coverage
pytest --cov=agentosx --cov-report=html
# Run tests for a specific agent
pytest tests/test_examples.py::test_simple_calculator_agent -v
# Watch mode (requires pytest-watch)
ptw -- -v# Start development server with hot reload
agentosx dev my-agent --watch
# Changes to agent.py or agent.yaml will auto-reload
# Perfect for rapid iteration!# Use the interactive playground
agentosx playground --agent=my-agent
# Or use Python debugger
python -m pdb examples/complete_example.py- Python 3.10+ (required)
- pydantic >= 2.0 - Data validation
- pyyaml - YAML parsing
- asyncio - Async runtime
- typing-extensions - Type hints
- tweepy - Twitter integration
- google-generativeai - Google Gemini LLM
- anthropic - Claude LLM
- openai - OpenAI LLM
- websockets - WebSocket transport
- sse-starlette - SSE transport
- typer - CLI framework
- rich - Terminal formatting
- pytest - Testing framework
- pytest-asyncio - Async tests
Install all dependencies:
pip install -r requirements.txt- ✅ MCP Protocol Implementation (JSON-RPC 2.0)
- ✅ MCP Server with tool/resource/prompt support
- ✅ MCP Client with dynamic discovery
- ✅ Transport layers (STDIO, SSE, WebSocket)
- ✅ Tool adapter with schema inference
- ✅ Enhanced BaseAgent with lifecycle hooks
- ✅ Agent loader from YAML manifests
- ✅ Streaming support with multiple formats
- ✅ SDK with fluent builder API
- ✅ LLM router with 7+ providers
- ✅ Policy system (content filters, rate limits, approvals)
- ✅ Memory systems (vector, buffer, hybrid)
- ✅ Central Coordinator (265 lines)
- ✅ Swarm-style Handoffs (347 lines)
- ✅ CrewAI-style Teams (456 lines)
- ✅ LangGraph-style Workflows (546 lines)
- ✅ Message Bus (359 lines)
- ✅ Agent Manifest Schema (274 lines)
- ✅ Template Agent (584 lines)
- ✅ Twitter Agent Migration (814 lines)
- ✅ Comprehensive Examples
- ✅ Blog Agent Manifest (447 lines)
Total Phase 2 Code: 3,800+ lines
- ✅ Rich CLI with 9 commands
- ✅ Hot reload functionality
- ✅ Interactive playground
- ✅ Testing infrastructure
- ✅ Comprehensive documentation (1,600+ lines)
- ✅ Example test suite (450+ lines)
- ✅ Testing guide (800+ lines)
- ✅ All tests passing (23/23)
- ✅ Production documentation
- ✅ Best practices guide
- ✅ Release preparation
- ✅ .gitignore configuration
- ✅ Package configuration (pyproject.toml)
🎉 AgentOSX v0.1.0 is Production-Ready!
- Web UI for orchestration monitoring
- Workflow visualization and debugging
- Performance metrics dashboard
- Blog Agent implementation completion
- Additional LLM providers (Cohere, Mistral)
- Enhanced marketplace features
- Multi-tenant support
- Cloud deployment templates
- Agent versioning and rollback
- Advanced policy engine
- Workflow template library
- Integration with popular AI frameworks
Have ideas for AgentOSX? Open an issue or join our discussions!
We welcome contributions from developers of all skill levels! AgentOSX is built by the community, for the community.
- 🐛 Bug Fixes: Help us identify and fix issues
- ✨ New Features: Add functionality to existing components
- 🤖 New Agents: Create agents for different use cases
- 📚 Documentation: Improve guides and help others understand the project
- 🧪 Testing: Write tests to ensure code quality
- 🎨 Examples: Share your agent implementations
- 💡 Ideas: Suggest improvements and new features
-
Fork the Repository
# Click the Fork button on GitHub git clone https://github.com/YOUR_USERNAME/agentOSX.git cd agentOSX
-
Create a Branch
git checkout -b feature/my-awesome-feature
-
Make Your Changes
- Write clear, documented code
- Follow existing code style
- Add tests for new features
- Update documentation
-
Run Tests
pytest tests/ -v
-
Commit and Push
git add . git commit -m "Add: Brief description of changes" git push origin feature/my-awesome-feature
-
Create Pull Request
- Go to your fork on GitHub
- Click "New Pull Request"
- Describe your changes clearly
- Code Style: Follow PEP 8 for Python code
- Type Hints: Use type hints for all function signatures
- Documentation: Add docstrings to all public functions
- Testing: Maintain 80%+ test coverage
- Commits: Use clear, descriptive commit messages
Check out issues labeled good first issue for beginner-friendly tasks!
- Discussions: GitHub Discussions
- Issues: Bug Reports & Feature Requests
- Discord: Coming soon!
This project follows our Code of Conduct. By participating, you agree to uphold this code. Please report unacceptable behavior to the maintainers.
AgentOSX is open-source software licensed under the MIT License.
MIT License
Copyright (c) 2025 The Agentic
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.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
See LICENSE for the full license text.
AgentOSX is built on the shoulders of giants. We'd like to thank:
- AgentOS - Inspiration for modular agent design
- MCP Protocol - For the Model Context Protocol specification
- OpenAI - For GPT models and API
- Anthropic - For Claude models
- LangChain - For AI application patterns
- CrewAI - For multi-agent collaboration patterns
- LangGraph - For workflow orchestration patterns
- Open Source Community - For amazing tools and libraries
Thank you to all the amazing contributors who have made this project possible! 💝
- Getting Started Guide
- Testing Guide
- API Reference
- FAQ (Coming soon)
- GitHub Discussions: Ask questions and share ideas
- GitHub Issues: Report bugs and request features
- Documentation: Comprehensive guides and examples
For commercial support, consulting, or custom development:
- Email: contact@theagentic.com (Coming soon)
- Website: https://theagentic.com (Coming soon)
If you find AgentOSX helpful, please consider giving it a star! ⭐
