Tallyfy enables physical robots to seamlessly integrate with workflow management through standard industrial protocols like OPC UA ROS and MQTT allowing robots to query process documentation mark tasks complete and provide real-time visibility into automated operations for enhanced human-robot collaboration.
Boston Dynamics integration
Boston Dynamics’ Spot robot has proven itself in 1,500+ deployments worldwide, with sophisticated Orbit fleet management software. While Orbit excels at mission recording and playback, it lacks dynamic procedure management and knowledge sharing capabilities essential for complex commercial operations.
Hardware platform:
- Spot robot: $74,500 quadruped with 14kg payload capacity
- Arm attachment: 6-DOF manipulator for door opening and valve operation
- Sensor payloads: Thermal cameras, gas detectors, LiDAR, acoustic sensors
- Enterprise connectivity: WiFi, LTE, and edge computing capabilities
Software ecosystem:
- Orbit platform: Fleet management and data centralization (formerly Scout)
- Mission recording: Create inspection routes through teaching
- Spot SDK: Comprehensive Python/C++ APIs for custom development
- Autowalk: Autonomous navigation with dynamic obstacle avoidance
- AI visual inspection: Vision-language models for anomaly detection
Operational capabilities:
- Record missions by manually walking routes
- Schedule automated mission playback
- Merge multiple recordings into cohesive maps
- Real-time monitoring through web interface
- Integration with enterprise asset management (EAM) systems
Current state: Spot missions are recordings of specific paths and actions. Once recorded, they play back exactly the same way each time:
- Missions are rigid sequences that can’t adapt
- No ability to query “how to” for new situations
- Changes require re-recording entire missions
- No conditional logic based on findings
Example problem: A Spot inspecting oil rigs encounters a new type of pressure gauge. The recorded mission doesn’t include inspection steps for this equipment. The robot either skips it or fails the mission entirely. An operator must manually re-record the entire route to include the new gauge.
How Tallyfy solves this: Spot queries Tallyfy mid-mission when encountering unrecognized equipment. It receives inspection procedures specific to the new gauge type, including acceptable pressure ranges, photo angles, and reporting requirements. The mission continues without interruption.
Current state: Each Spot operates with its own mission recordings:
- Improvements discovered by one robot don’t transfer to others
- No mechanism to capture operational optimizations
- Each deployment recreates similar missions from scratch
- No standardization across facilities
Example problem: A Spot at a chemical plant discovers that thermal imaging works better at dawn when temperature differentials are highest. This insight remains locked in that single robot’s deployment. Spots at other facilities continue inefficient midday inspections.
How Tallyfy solves this: When Spot identifies the optimal inspection timing, it updates the thermal imaging SOP in Tallyfy with supporting data. All Spots across all facilities immediately access this improvement. The entire fleet becomes more effective overnight.
Current state: Orbit provides data collection but limited procedural documentation:
- Records what data was captured, not what procedures were followed
- No versioning of inspection procedures
- Limited context for why specific actions were taken
- Difficult to prove compliance with industry standards
Example problem: A nuclear facility uses Spot for radiation monitoring. Regulators require proof that specific NRC inspection procedures were followed, not just that data was collected. Orbit shows the robot’s path and readings but can’t document adherence to regulatory procedures.
How Tallyfy solves this: Spot launches NRC-compliant inspection processes in Tallyfy, documenting each procedural step with timestamps, measurements, and photos. Complete audit trails prove regulatory compliance, showing not just what was inspected but that approved procedures were followed.
Let’s cut through the marketing and explain what really happens:
-
Missions are recorded walks that play back exactly:
- Operator physically drives Spot through facility with controller
- Robot saves GPS waypoints and camera snapshots
- This creates a static .walk file stored on tablet/Orbit
- Playback means “follow these exact breadcrumbs”
- If environment changes significantly? Mission fails
From Boston Dynamics’ own SDK documentation (Autowalk Service ↗):
- “The autowalk format forces programs into the ‘go here, do this’ pattern, which is a flexibility loss”
- “The Walk proto defines the autowalk’s linear series of actions and their associated locations”
- “At their core they are very simple: go to location A, perform action 1, go to location B, perform action 2, etc.”
-
“Adaptive” means basic obstacle avoidance, not intelligence:
# What Spot's mission actually looks like internallymission = {"waypoint_1": {"x": 10.5, "y": 20.3, "action": "capture_thermal"},"waypoint_2": {"x": 15.2, "y": 20.3, "action": "capture_photo"},# If new equipment appears at waypoint_3? Spot has no clue what to do}- Can walk around a traffic cone (basic obstacle avoidance)
- Cannot figure out how to inspect new equipment
- Cannot optimize its route based on findings
- Cannot skip unnecessary inspections
-
Zero learning or improvement capability:
- Spot at Site A discovers optimal inspection angle
- Spot at Site B will never know this
- No mechanism to share insights between robots
- Each deployment starts from scratch
- Improvements require manual mission re-recording
Per Boston Dynamics SDK (Mission Recorder ↗):
- “You must have a fiducial marker printed out and posted in a place that is visible to Spot”
- “Move the robot using the wasd keys to the desired starting point”
- Each mission must be manually recorded at each site
- No mechanism for cross-site mission sharing or improvement
Scenario: Oil rig adds new pressure gauge between waypoints
What marketing says: “Dynamic replanning” and “AI-powered inspection”
What actually happens:
- Spot reaches area with new gauge
- Mission file has no waypoint for this location
- Spot walks right past it (missed inspection)
- Operator must:
- Manually drive Spot to site again
- Re-record entire mission or section
- Test new recording
- Deploy to all Spots individually
- Each site must do this independently
What Orbit shows: Pretty map with robot location
What’s missing:
- No task-level visibility (“Inspecting gauge #47”)
- No procedure tracking (“Step 3 of API-570 inspection”)
- No workflow context (“This inspection feeds into maintenance request”)
- Just dots on a map and timestamp logs
Example of actual Orbit data:
14:32:05 - Reached waypoint 2314:32:07 - Captured thermal image14:32:45 - Reached waypoint 24Compare to what’s needed for compliance:
14:32:05 - Started API-570 pressure vessel inspection14:32:07 - Completed thermal scan per section 5.3.214:32:45 - Thickness measurement: 4.2mm (PASS per spec)200 missions per facility is common. Here’s what that means:
- Each mission is a separate file to maintain
- Change in facility layout? Update dozens of missions manually
- No way to update common inspection procedures across missions
- Engineers spending more time managing missions than improving operations
- Version control? What version control?
Boston Dynamics acknowledges this complexity (Autowalk Documentation ↗):
- “The corresponding behavior trees are very deep (42 layers) and very wide (1000’s of nodes)”
- “If a Walk proto is malformed, the autowalk to mission compilation will fail”
- Missions require “constant communication with the robot” for script advancement
- “Directed Exploration is invoked as a last resort when all other attempts to find a path have failed”
What to notice:
- Tallyfy Bridge extends missions with dynamic procedures
- Orbit continues handling telemetry and fleet management
- All procedural decisions are documented for compliance
Tallyfy Bridge for Spot (Python service):
# Example integrationfrom bosdyn.client import create_standard_sdkfrom tallyfy_bridge import TallyfyClient
# Initialize connectionssdk = create_standard_sdk('TallyfyBridge')robot = sdk.create_robot('192.168.10.10')tallyfy = TallyfyClient(api_key='...')
# During mission executiondef on_waypoint_reached(waypoint): # Check for equipment at this location equipment = detect_equipment(robot.image_client)
if equipment.type not in mission.known_equipment: # Query Tallyfy for inspection procedure procedure = tallyfy.get_procedure( f"inspect_{equipment.type}" )
# Execute dynamic inspection process = tallyfy.launch_process(procedure.id) for step in procedure.steps: execute_inspection_step(robot, step) tallyfy.complete_task(process.id, step.id, { "thermal_image": capture_thermal(), "measurements": read_sensors(), "anomalies": detect_anomalies() })Without Tallyfy:
- 200+ individual mission recordings
- 3-4 days to update for new equipment
- Manual correlation of findings to procedures
- Difficult regulatory compliance reporting
With Tallyfy:
- Dynamic procedures for all equipment types
- Instant updates for new inspection requirements
- Automatic compliance documentation
- Cross-facility best practice sharing
Without Tallyfy:
- Static thermal scanning routes
- No adaptation to server configuration changes
- Limited root cause analysis
- Isolated facility operations
With Tallyfy:
- Adaptive inspection based on server criticality
- Dynamic response to thermal anomalies
- Integrated incident response workflows
- Fleet-wide optimization insights
Without Tallyfy:
- Rigid NRC compliance procedures
- Manual documentation of inspections
- No procedure version control
- Time-consuming audits
With Tallyfy:
- Version-controlled NRC procedures
- Real-time compliance tracking
- Automatic audit report generation
- Instant regulatory updates
Orbit handles:
- Fleet management and monitoring
- Mission recording and scheduling
- Telemetry and sensor data storage
- Real-time robot tracking
- Basic AI visual analysis
Tallyfy adds:
- Dynamic procedure management
- Cross-robot knowledge sharing
- Compliance documentation
- Continuous improvement workflows
- Human-robot collaboration
The combination creates a complete operational platform:
- Orbit manages the “where and when” of inspections
- Tallyfy provides the “how and why” of procedures
- Together they enable truly adaptive autonomous operations
- Deploy Tallyfy Bridge at single facility
- Convert key procedures to Tallyfy SOPs
- Test dynamic procedure injection
- Validate audit trail generation
- Implement cross-robot learning
- Add exception handling workflows
- Enable procedure optimization detection
- Integrate with Orbit webhooks
- Scale to multiple facilities
- Implement compliance reporting
- Add predictive maintenance workflows
- Enable fleet-wide analytics
- Integrate Spot’s AI insights with Tallyfy
- Automated procedure generation
- Predictive failure detection
- Continuous optimization loops
- 60% reduction in mission maintenance time: Dynamic procedures eliminate re-recording
- 40% improvement in inspection coverage: Adaptive procedures catch more issues
- 80% faster regulatory audits: Automatic compliance documentation
- 35% reduction in false positives: Shared learning improves detection accuracy
- Regulatory confidence: Provable compliance with industry standards
- Operational excellence: Best practices propagate instantly
- Scalability: Manage 100+ Spots from single knowledge base
- Future-proofing: Procedures evolve with changing requirements
- Current state assessment: Analyze existing Orbit missions and procedures
- Procedure standardization: Create SOP library in Tallyfy
- Pilot deployment: Start with 1-2 Spots at single facility
- Integration setup: Install Tallyfy Bridge alongside Orbit
- Operator training: Educate teams on enhanced capabilities
- Scaling strategy: Expand based on pilot success metrics
- Spot robots with SDK access
- Orbit platform (cloud or on-premise)
- Network connectivity for API communication
- Tallyfy organization with API access
- Python 3.8+ environment for Bridge service
- Optional: Edge compute for low-latency processing
- Tallyfy Bridge installation guide
- Spot SDK integration examples
- Procedure template library
- Compliance reporting templates
- Enterprise support channel
- Community forum for Spot operators
Robotics > Unitree Robotics integration
Unitree has revolutionized robotics with affordable quadrupeds and humanoids but lacks the operational workflow layer needed for commercial deployments where Tallyfy fills critical gaps in knowledge lookup continuous improvement and real-time tracking that current hardcoded programming approaches cannot address.
Robotics > Universal Robots integration
Universal Robots cobots excel at hardware integration through PolyScope X and URCaps but lack dynamic SOP management and knowledge sharing capabilities that Tallyfy provides through seamless URCap integration enabling real-time procedure queries cross-robot learning and comprehensive compliance documentation for enterprise-scale collaborative robotics deployments.
Robotics > KUKA Robotics integration
KUKA robots excel at hardware engineering with powerful payload capabilities up to 1300kg but remain trapped in 1990s software paradigms where static KRL files are manually copied via USB sticks to individual controllers creating deployment chaos across robot fleets with zero adaptability learning capability or real-time process tracking while Tallyfy transforms this by enabling robots to dynamically query current procedures share knowledge across all units and maintain complete audit trails for true intelligent automation.
About Tallyfy
- 2025 Tallyfy, Inc.
- Privacy Policy
- Terms of Use
- Report Issue
- Trademarks