Deep-dive documentation for power users who want to understand Marcus's sophisticated intelligence, memory, and support systems.
Explore the advanced capabilities that make Marcus an intelligent coordination platform, not just a project tracker. Learn about the four-tier memory system, agent support tools, status monitoring, and diagnostic capabilities.
- Power users maximizing Marcus capabilities
- System architects understanding deep integration
- Developers building advanced agent behaviors
- Researchers studying multi-agent learning
Marcus's four-tier cognitive architecture that enables continuous learning, predictive intelligence, and process optimization.
What you'll learn:
- Working Memory - Immediate project state and real-time intelligence
- Episodic Memory - Detailed event recording for pattern recognition
- Semantic Memory - General knowledge about agents, tasks, and patterns
- Procedural Memory - Process optimization and best practices
- Cross-tier learning integration
- Memory consolidation (episodic → semantic)
- Predictive intelligence generation
- Memory-driven insights for optimization
Why it matters: Memory is how Marcus learns from every project and gets smarter over time
Systems involved: 4-tier architecture with cross-tier integration, consolidation, and intelligence generation
Comprehensive overview of tools that help agents work effectively: ping, context, decision logging, artifact tracking, and dependency checking.
What you'll learn:
- How support tools integrate with core systems
- Agent-focused health verification with project context
- Task context intelligence with dependency analysis
- Decision audit trail with impact analysis
- Artifact tracking with knowledge integration
- Dependency validation with predictive intelligence
Why it matters: Support tools transform Marcus into a comprehensive agent intelligence platform
Key tools covered: ping, get_task_context, log_decision, log_artifact, check_task_dependencies
Query comprehensive agent performance, health, and intelligence for optimization and strategic planning.
What you'll learn:
- Multi-source data collection (assignments, performance, communication, health)
- Performance trajectory analysis and comparative assessment
- Workload capacity analysis and optimization opportunities
- Health assessment across multiple dimensions
- Predictive risk analysis for agent performance
- AI-powered optimization recommendations
- Future performance predictions
- Team integration analysis and strategic development recommendations
Why it matters: Understand agent performance for optimization, development, and strategic planning
Systems involved: Agent Coordination, Assignment Data, Memory, Performance Analytics, Health Monitoring, AI Engine, Intelligence Synthesis (6+ stages)
Intelligent system connectivity verification that provides comprehensive health information tailored to client type.
What you'll learn:
- Client type detection (agent vs Cato vs Claude Desktop)
- Agent-specific health information and service readiness
- Project context validation and registration status
- Tailored responses based on client capabilities
- System health assessment and integration verification
Why it matters: Ping provides comprehensive system intelligence, not just "I'm alive"
Systems involved: Agent Coordination, Logging, System Monitoring, Service Registry, Project Context (4+ stages)
Marcus predicts future project state using historical patterns:
- Completion Time Forecasting - When will tasks/projects finish?
- Blockage Probability - What might cause problems?
- Cascade Impact Analysis - How will changes affect downstream work?
- Resource Optimization - Where to allocate agents for maximum efficiency?
Based on: Historical performance, task complexity, dependency analysis, agent capabilities
Every Marcus operation contributes to learning:
- Pattern Recognition - Identify what works well
- Failure Analysis - Learn from problems
- Performance Optimization - Improve recommendations
- Process Refinement - Better workflows over time
Memory tiers work together: Working (now) → Episodic (what happened) → Semantic (general patterns) → Procedural (best practices)
Marcus makes agents smarter through:
- Context Provision - Rich task understanding
- Dependency Awareness - Know what came before and what depends on you
- Historical Patterns - Learn from similar completed tasks
- Predictive Guidance - Anticipate problems before they occur
- Blocker Resolution - AI-powered suggestions when stuck
Complete visibility into system operation:
- Health Monitoring - Real-time system status
- Performance Tracking - Agent and task metrics
- Audit Trails - Complete history of all actions
- Diagnostic Tools - Troubleshoot integration issues
- Pattern Analysis - Understand coordination effectiveness
- When building long-term agent intelligence
- For cross-project pattern application
- To improve predictions over time
- For understanding system learning
- During agent development and testing
- For comprehensive status checking
- When logging important decisions
- To track shareable artifacts
- For dependency validation
- For performance optimization
- When planning agent development
- To identify workload imbalances
- For team integration analysis
- To predict future performance
- For connectivity verification
- During integration debugging
- To validate system health
- For client-specific information
- Before critical operations
1. Use ping to verify connectivity
2. Check agent status for performance baseline
3. Use support tools during task execution
4. Monitor memory integration for learning
5. Analyze patterns for optimization
1. Ping system to verify basic connectivity
2. Check agent status for anomalies
3. Review memory for historical context
4. Use support tools to gather detailed information
5. Analyze patterns to identify root cause
1. Query agent status for performance metrics
2. Review memory for successful patterns
3. Apply support tools to validate dependencies
4. Monitor system health continuously
5. Iterate based on predictive intelligence
For Memory System:
- Trust the learning process—don't micromanage
- Provide clear task outcomes for better learning
- Review memory-driven recommendations
- Use predictions to guide decisions
For Agent Support Tools:
- Use ping before critical operations
- Get context when tasks have dependencies
- Log decisions immediately when made
- Track artifacts as soon as created
- Check dependencies before starting work
For Agent Status:
- Monitor regularly for early problem detection
- Compare performance across agents
- Act on optimization recommendations
- Use for strategic planning
For Diagnostics:
- Run health checks proactively
- Address issues before they cascade
- Use diagnostic tools during debugging
- Monitor integration points continuously
- Want to understand learning? → Memory System
- Building advanced agents? → Agent Support Tools
- Optimizing performance? → Agent Status
- Debugging issues? → Ping System
- Need API details? → API Reference
Philosophy: These advanced features make Marcus intelligent, not just functional. They're the difference between tracking work and understanding it.