<?xml version="1.0" encoding="UTF-8"?><rss version="2.0">
<channel>
<description>ContentBox RSS Feed</description>
<link>https://www.ortussolutions.com</link>
<title>Blog RSS Feed by ContentBox</title>
<copyright>Ortus Solutions, Corp (www.ortussolutions.com)</copyright>
<docs>http://www.rssboard.org/rss-specification</docs>
<generator>FeedGenerator</generator>
<lastBuildDate>Wed, 06 May 2026 17:59:23 GMT</lastBuildDate>
<pubDate>Wed, 06 May 2026 17:59:23 GMT</pubDate>
<item>
<title>Ortus &amp; BoxLang April Recap 2026</title>
<description>This collection brings together the latest updates, releases, events, and insights from the Ortus ecosystem, covering BoxLang, ColdBox, and modern CFML development. From major product launches and AI advancements to in-depth technical guides and real-world modernization strategies, these resources highlight how developers and organizations are building scalable, future-ready applications on the JVM.
It also captures key moments from the community, including webinars and major events like Into the Box 2026, showcasing the ongoing innovation, collaboration, and evolution happening across the Ortus world.
Product Releases &amp;amp; Tools
Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang &amp;amp; the Ortus World
This post introduces skills.boxlang.io, a public, agent-agnostic registry of reusable AI “skills” for the entire Ortus ecosystem. It enables teams to define, version, and share structured AI knowledge across tools like Copilot and Claude, eliminating prompt duplication and creating a scalable, standardized way to power intelligent agents
Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang &amp;amp; the Ortus World
This post introduces skills.boxlang.io, a public, agent-agnostic registry of reusable AI “skills” for the entire Ortus ecosystem. It enables teams to define, version, and share structured AI knowledge across tools like Copilot and Claude, eliminating prompt duplication and creating a scalable, standardized way to power intelligent agents.
Introducing cbMCP — Your ColdBox App, Live to Every AI Agent
This post introduces cbMCP, a ColdBox module that turns your running application into a live MCP server for AI agents. It allows tools like Claude or Copilot to directly inspect routes, handlers, and system state in real time—eliminating guesswork and enabling smarter, context-aware AI development.
Build Cross-Platform Desktop Apps with BoxLang
This post introduces the new BoxLang Desktop Runtime, enabling developers to build cross-platform desktop apps using Electron, Vite, and BoxLang. It highlights a “write once, run anywhere” approach—allowing the same codebase to run on macOS, Windows, and Linux with minimal setup and no rewrites.
Introducing BoxLings! An Interactive Teacher for BoxLang and TDD/BDD
This post introduces BoxLings, an interactive CLI learning tool that teaches BoxLang through hands-on exercises and real test feedback. It combines 100+ progressive challenges with a TDD/BDD-first approach, helping developers learn by fixing code, reading tests, and building real skills step by step.
BoxLang Goes Serverless on Google Cloud
This post highlights how BoxLang expands its multi-runtime capabilities by enabling serverless deployments on Google Cloud. It shows how developers can run event-driven functions without managing infrastructure, taking advantage of automatic scaling, faster development cycles, and cost-efficient cloud execution.
ColdBox 8.1.0 Released: AI Routing, MCP, and BoxLang-First Power
This release introduces powerful AI-focused features like toAi() and toMCP() routing, enabling developers to instantly expose AI agents and MCP servers via REST endpoints. It also includes scheduler improvements, better cluster reliability, and deeper alignment with BoxLang as a first-class runtime.
Content &amp;amp; Resources
The Loneliness of CTO Leadership: How to Make Important Decisions with Confidence
This article explores the isolation that often comes with CTO leadership and how it affects decision-making. It highlights strategies like building advisory circles and using structured frameworks to make more confident, high-impact decisions.
BoxLang AI Series: Complete Guide to Building AI Agents
This post brings together the full BoxLang AI series into a complete guide for building production-ready AI agents. It covers core concepts like tools, memory, and agent orchestration, showing how to design scalable, intelligent systems that can reason, act, and integrate with real-world data and APIs.
ColdFusion Modernization for UK Universities (Without Downtime)
This article explores how UK universities modernize legacy ColdFusion systems without disrupting critical services. It highlights strategies like phased upgrades, cloud adoption, and zero-downtime deployments to maintain uptime while improving performance, security, and scalability.
BoxLang Updates
BoxLang v1.13.0: Compatibility, Concurrency, and Formatter Maturity
This release focuses on stability and production readiness, delivering major improvements in CFML compatibility, concurrency handling, and runtime reliability. It also introduces a production-ready formatter with CI/CD support, along with security and performance fixes across the platform.
BoxLang AI v3 Has Landed: Multi-Agent Orchestration, Tooling, Skills and So Much More
This post announces the release of BoxLang AI v3, a major update that redefines how AI agents, models, and tools interact within the BoxLang ecosystem. It introduces a powerful AI Skills system for reusable, versioned knowledge, along with multi-agent orchestration, MCP server integration, and a revamped tooling architecture—enabling developers to build more scalable, modular, and intelligent AI-driven applications on the JVM.
Mini serie of BoxLang AI BoxLang AI Deep Dive
BoxLang AI Deep Dive — Part 1 of 7: The Skills Revolution (AI 3.0 Series)
This post kicks off a 7-part deep dive series on building production-ready AI systems with BoxLang AI 3.0. It introduces the concept of “AI Skills” as reusable, versioned knowledge modules that eliminate prompt duplication and inconsistency across agents. By treating instructions as structured, shareable assets, developers can create more scalable, maintainable, and consistent AI-driven systems across their applications.
BoxLang AI Deep Dive — Part 2 of 7: Building a Production-Grade AI Tool Ecosystem (AI 3.0 Series)
This post continues the BoxLang AI 3.0 deep dive series, focusing on how to build a scalable and production-ready AI tool ecosystem. It explores the internal architecture behind tools—introducing components like BaseTool, ClosureTool, and the global tool registry—designed to handle lifecycle management, observability, and execution automatically. By abstracting complexity away from developers, BoxLang enables consistent, reusable, and modular tool integration across AI agents and workflows.
BoxLang AI Deep Dive — Part 3 of 7: Multi-Agent Orchestration — Building AI Teams That Work (AI 3.0 Series)
This post explores how BoxLang AI 3.0 enables true multi-agent orchestration by introducing hierarchical agent structures where agents can delegate tasks to specialized sub-agents automatically. It highlights how agents are organized in a tree with built-in cycle detection, stateless execution, and per-call memory isolation—allowing developers to build scalable “AI teams” that collaborate efficiently without manual wiring or complex coordination logic.
BoxLang AI Deep Dive — Part 4 of 7: Middleware — The Missing Layer in Every AI Framework (AI 3.0 Series)
This post dives into the middleware system in BoxLang AI 3.0, introducing a critical layer that sits between agent execution and actual LLM/tool interactions. It explains how middleware enables cross-cutting concerns like logging, retries, guardrails, and human-in-the-loop validation without modifying core agent logic. By using a hook-based lifecycle and composable middleware stack, developers can gain full control, observability, and testability of AI workflows—solving one of the biggest challenges in building reliable, production-grade AI systems.
BoxLang AI Deep Dive — Part 5 of 7: One API, 17 Providers — The Provider Architecture Deep Dive (AI 3.0 Series)
This post explores the provider architecture behind BoxLang AI 3.0, focusing on how a single unified API can seamlessly support 17 different AI providers. It introduces a capability-based system that ensures type-safe interactions, prevents runtime errors, and allows developers to switch providers with zero code changes. By abstracting provider-specific logic into a structured hierarchy and transport layer, BoxLang eliminates vendor lock-in and enables flexible, future-proof AI integrations across cloud and local environments.
BoxLang AI Deep Dive — Part 6 of 7: Memory Systems &amp;amp; RAG — Building AI That Remembers (AI 3.0 Series)
This post explores how BoxLang AI 3.0 implements advanced memory systems and Retrieval-Augmented Generation (RAG) to build AI applications that retain context and knowledge over time. It introduces two core memory types—standard memory for conversation history and vector memory for semantic retrieval—along with over 20 memory strategies, document loaders, and multi-tenant identity routing. By combining short-term context with long-term knowledge through hybrid memory, developers can build intelligent AI systems that are context-aware, scalable, and grounded in real data rather than relying solely on model responses.
BoxLang AI Deep Dive — Part 7 of 7: MCP — The Protocol That Connects Everything (AI 3.0 Series)
This final post in the BoxLang AI 3.0 series explores the Model Context Protocol (MCP), a standardized way for AI agents to discover and interact with tools across different systems and languages. It explains how BoxLang acts as both an MCP client and server—allowing developers to consume external tools or expose their own—while eliminating integration complexity. By adopting MCP, BoxLang enables a truly interoperable AI ecosystem where agents, tools, and services can seamlessly connect regardless of implementation.
How to Develop AI Agents Using BoxLang AI: A Practical Guide
This hands-on guide walks through how to build real-world AI agents using BoxLang AI, moving beyond simple chatbots into systems that can reason, act, and remember. It covers core concepts like tools, memory, and agents, and demonstrates how to create a production-ready support agent capable of querying data, calling APIs, and handling multi-step workflows. The article emphasizes a unified API approach, multi-provider flexibility, and scalable architecture for building intelligent, autonomous applications on the JVM.
Updates
BoxLang v1.12.0: Destructuring, Spread, Ranges, Watchers, Oh My!
This release introduces major language enhancements like destructuring, spread syntax, and a new range operator, along with real-time file watchers and performance improvements. It marks a shift toward more expressive, modern development features while continuing to improve stability and speed across the BoxLang ecosystem.
BoxLang AI v3.1 Released: Audio, Async, Parallel Pipelines, and More
This release expands BoxLang AI with audio capabilities, async execution, and parallel pipelines, enabling faster and more scalable AI workflows. It also adds new tooling, provider support, and stability improvements for production-ready AI applications.
Ortus Upcoming Events &amp;amp; Webinars
CFCamp Pre-Conference Workshops Led by Ortus Solutions
Ortus Solutions is hosting hands-on pre-conference workshops at CFCamp, designed to give developers practical experience with CFML, Ortus tools, and best practices before the main event kicks off.
Save your Spot
Ortus Past Events
Join Our Webinar: Intro to BoxLang AI – One API to Rule Them All (Part II)
This post highlights a webinar held on April 16, 2026, focused on building production-ready AI workflows using BoxLang AI. It showcases how developers can leverage a single unified API to work across multiple AI providers, create autonomous agents, and build scalable RAG pipelines—demonstrating practical approaches to modern AI development on the JVM.
Into the Box 2026 is Here: Learn All the Details!
This post highlights Into the Box 2026, held from April 29 to May 1 in Washington, DC, under the theme “Modernization in Motion: Building a Dynamic Future.” The event featured deep dives into BoxLang, AI, cloud-native development, and modern architectures, along with hands-on workshops, networking opportunities, and full access to session recordings and resources.
Watch the Keynote 01 &amp;amp; 02
Join the Ortus Community
Be part of the movement shaping the future of web development. Stay connected and receive the latest updates on, product launches, tool updates, promo services and much more.
Subscribe to our newsletter for exclusive content.
Subscribe
Follow Us on Social media and don’t miss any news and updates:
https://twitter.com/ortussolutions
https://www.facebook.com/OrtusSolutions
https://www.linkedin.com/company/ortus-solutions-corp
https://www.youtube.com/OrtusSolutions
https://github.com/Ortus-Solutions
</description>
<link>https://www.ortussolutions.com/blog/ortus-boxlang-april-recap-2026</link>
<pubDate>Tue, 05 May 2026 19:49:00 GMT</pubDate>
<author>vcampos@ortussolutions.com (Victor Campos)</author>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/ortus-boxlang-april-recap-2026</guid>
</item>
<item>
<title>BoxLang v1.13.0: Compatibility, Concurrency, and Formatter Maturity</title>
<description>BoxLang 1.13.0 is here, and it marks an important step forward for the platform. This release includes 48 tickets—every one of them completed—reflecting a focused effort on CFML compatibility, a more robust concurrency engine, a production-hardened miniserver, and meaningful tooling improvements.</description>
<link>https://www.ortussolutions.com/blog/boxlang-v1130-compatibility-concurrency-and-formatter-maturity</link>
<pubDate>Thu, 30 Apr 2026 18:05:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>Community</category>
<category>Into The Box</category>
<category>News</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/boxlang-v1130-compatibility-concurrency-and-formatter-maturity</guid>
</item>
<item>
<title>&#128640; ColdBox CLI 8.11: The Era of AI Skills Comes to Every ColdBox &amp; BoxLang App</title>
<description>ColdBox CLI 8.11 is here, and it's one of the most significant releases we've shipped for AI-assisted development. This release wires the CLI directly into our brand new public skills directory at skills.boxlang.io, brings our AI tooling in line with industry-wide agent conventions, and introduces a wave of quality-of-life improvements that make AI integration feel less like setup and more like infrastructure.</description>
<link>https://www.ortussolutions.com/blog/coldbox-cli-811-the-era-of-ai-skills-comes-to-every-coldbox-boxlang-app</link>
<pubDate>Thu, 30 Apr 2026 08:00:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>ColdBox MVC</category>
<category>ColdFusion</category>
<category>News</category>
<category>OpenSource</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/coldbox-cli-811-the-era-of-ai-skills-comes-to-every-coldbox-boxlang-app</guid>
</item>
<item>
<title>&#127891; Introducing skills.boxlang.io — The Open Agent Skills Ecosystem for BoxLang &amp; the Ortus World</title>
<description>Today we're launching something we've been quietly building for months: skills.boxlang.io — a public, agent-agnostic directory for AI skills covering BoxLang, ColdBox, TestBox, CommandBox, and the entire Ortus ecosystem.</description>
<link>https://www.ortussolutions.com/blog/introducing-skillsboxlangio-the-open-agent-skills-ecosystem-for-boxlang-the-ortus-world</link>
<pubDate>Thu, 30 Apr 2026 08:00:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>ColdBox MVC</category>
<category>ColdFusion</category>
<category>News</category>
<category>OpenSource</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/introducing-skillsboxlangio-the-open-agent-skills-ecosystem-for-boxlang-the-ortus-world</guid>
</item>
<item>
<title>&#128752;️ Introducing cbMCP — Your ColdBox App, Live to Every AI Agent</title>
<description>Today we're releasing cbMCP, the official ColdBox MCP Server — a BoxLang-only module that turns your running ColdBox application into a fully-compliant Model Context Protocol (MCP) server. Plug in any MCP-capable AI client — Claude Desktop, VS Code Copilot, Cursor, Codex, Gemini CLI, OpenCode — and your AI assistant gets live, read-only introspection across the entire ColdBox platform: routing, handlers, modules, WireBox, CacheBox, LogBox, schedulers, interceptors, and async executors. &#127919;</description>
<link>https://www.ortussolutions.com/blog/introducing-cbmcp-your-coldbox-app-live-to-every-ai-agent</link>
<pubDate>Thu, 30 Apr 2026 08:00:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>ColdBox MVC</category>
<category>ColdFusion</category>
<category>News</category>
<category>OpenSource</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/introducing-cbmcp-your-coldbox-app-live-to-every-ai-agent</guid>
</item>
<item>
<title>&#128421;️ Build Cross-Platform Desktop Apps with BoxLang</title>
<description>Today we're shipping the initial release of the BoxLang Desktop Runtime — powered by Electron, BoxLang, and Vite. With one starter, one npm run dev, and one packaging command, you can build and distribute professional desktop applications for macOS, Windows, and Linux using the BoxLang you already know. &#127919;</description>
<link>https://www.ortussolutions.com/blog/build-cross-platform-desktop-apps-with-boxlang</link>
<pubDate>Thu, 30 Apr 2026 08:00:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>ColdBox MVC</category>
<category>ColdFusion</category>
<category>News</category>
<category>OpenSource</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/build-cross-platform-desktop-apps-with-boxlang</guid>
</item>
<item>
<title>BoxLang AI v3.1 Released - Audio, Async, Parallel Pipelines, and More &#127908;⚡&#128256;</title>
<description>BoxLang AI 3.1 is here, and it's a release that makes your agents smarter, faster, and more capable than ever. &#127881;</description>
<link>https://www.ortussolutions.com/blog/boxlang-ai-v31-released-audio-async-parallel-pipelines-and-more</link>
<pubDate>Mon, 20 Apr 2026 09:00:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>Community</category>
<category>Into The Box</category>
<category>News</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/boxlang-ai-v31-released-audio-async-parallel-pipelines-and-more</guid>
</item>
<item>
<title>ColdBox 8.1.0 Released — AI Routing, MCP, and BoxLang-First Power! &#128640;</title>
<description>We are thrilled to announce ColdBox 8.1.0, a targeted minor release packed with powerful new features, important improvements, and critical bug fixes across ColdBox, WireBox, and CacheBox. While minor in version number, this release delivers some truly exciting capabilities — especially for BoxLang developers building AI-powered applications.</description>
<link>https://www.ortussolutions.com/blog/coldbox-810-released-ai-routing-mcp-and-boxlang-first-power</link>
<pubDate>Tue, 14 Apr 2026 20:37:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>CacheBox</category>
<category>ColdBox MVC</category>
<category>CommandBox</category>
<category>ContentBox CMS</category>
<category>LogBox</category>
<category>WireBox</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/coldbox-810-released-ai-routing-mcp-and-boxlang-first-power</guid>
</item>
<item>
<title>ColdFusion Modernization for UK Universities Without Downtime</title>
<description>Across the United Kingdom, many universities still rely on legacy ColdFusion and CFML systems to power student portals, enrollment platforms, research databases, payment gateways, and internal academic workflows.
These systems are often:
15 to 25 years old
Mission-critical
Deeply integrated with student information systems
Running on older Adobe ColdFusion or Lucee versions
Tightly coupled monolithic architectures
For UK universities, modernization is no longer optional. However, the challenge is clear:
How do you modernize a legacy ColdFusion university portal without disrupting students, faculty, and administrative operations?
Why ColdFusion Still Powers UK University Portals
ColdFusion became popular in UK universities during the early 2000s because it allowed rapid development of:
Student application portals
Course management systems
Alumni platforms
Financial aid and bursary systems
Internal administrative dashboards
Over time, these systems evolved into large CFML legacy platforms, often with limited documentation, mixed coding styles, and minimal automated testing.
Today, many UK university IT departments face growing pressure to:
Improve security compliance under GDPR
Reduce operational risk
Migrate to cloud infrastructure
Improve scalability during enrollment peaks
Reduce dependency on a shrinking CFML talent pool
The Real Risk: Downtime in Higher Education Systems
In the United Kingdom, university systems cannot fail during:
Enrollment periods
Exam results publication
Tuition payment deadlines
Student visa processing
Clearing season
Any downtime during these periods can result in:
Reputational damage
Student dissatisfaction
Financial losses
Compliance concerns
This makes a full rewrite unrealistic.
Most UK universities cannot afford to shut down their ColdFusion portals for months while rebuilding them from scratch.
Common Problems in UK ColdFusion University Systems
Through our work with legacy CFML systems, we consistently see similar patterns:
1. Monolithic Architectures
Many university portals were built as single large applications without modular separation.
2. Outdated Adobe ColdFusion Versions
Older ACF versions increase security and compliance risk, particularly under GDPR.
3. Manual Deployments
Lack of CI/CD pipelines increases deployment risk.
4. Limited Observability
No distributed tracing, inconsistent logs, and insufficient monitoring.
5. Talent Scarcity
Fewer developers in the United Kingdom specialize in ColdFusion, increasing operational risk.
A Safer Path: Progressive ColdFusion Modernization in the UK
Modernizing ColdFusion systems in UK universities does not require a disruptive rewrite.
A structured approach includes:
Step 1: Technical and Security Audit
Assess the ColdFusion stack, JVM configuration, dependencies, and infrastructure.
Step 2: Stabilization and Hardening
Upgrade outdated components, apply security patches, improve configuration.
Step 3: Progressive Refactoring
Break monolithic CFML systems into modular ColdBox or HMVC structures.
Step 4: CI/CD Implementation
Introduce automated pipelines to reduce deployment risk.
Step 5: Cloud-Ready Architecture
Prepare the system for containerization, Kubernetes, or hybrid cloud environments.
This approach ensures:
Zero downtime modernization
Operational continuity
Compliance alignment
Long-term sustainability
Cloud Migration for UK Universities Running ColdFusion
Many universities in the United Kingdom are moving toward:
AWS UK regions
Azure UK South / UK West
Hybrid cloud strategies
However, legacy CFML systems often struggle with:
Containerization
Kubernetes orchestration
Modern DevOps workflows
With the right modernization framework, ColdFusion applications can be:
Containerized safely
Deployed via CI/CD pipelines
Integrated with modern authentication systems
Scaled for peak academic traffic
Reducing Risk Without Rewriting Everything
A full rebuild is expensive, risky, and politically complex in university environments.
A progressive modernization strategy allows UK universities to:
Protect existing investment
Reduce technical debt
Improve security posture
Introduce modern cloud-native capabilities
Maintain continuous service for students and faculty
Why UK Universities Choose Specialized CFML Modernization Partners
Modernizing ColdFusion in the United Kingdom requires:
Deep CFML expertise
Understanding of GDPR and UK compliance standards
Experience with zero-downtime migrations
Knowledge of cloud-native transformation
Ability to train internal IT teams
A specialized partner can help universities move forward without disrupting academic operations.
Final Thoughts
ColdFusion still plays a critical role in many UK university systems.
The question is no longer whether modernization will happen, but how it will be executed.
The safest path forward is structured, progressive modernization that preserves operational continuity while preparing systems for the next decade.
If your university in the United Kingdom relies on ColdFusion or CFML for critical platforms, now is the time to evaluate a safe and controlled modernization roadmap. Contact us.
</description>
<link>https://www.ortussolutions.com/blog/coldfusion-modernization-for-uk-universities-without-downtime</link>
<pubDate>Mon, 13 Apr 2026 12:17:00 GMT</pubDate>
<author>cristobal@ortussolutions.com (Cristobal Escobar)</author>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/coldfusion-modernization-for-uk-universities-without-downtime</guid>
</item>
<item>
<title>BoxLang AI Series: Complete Guide to Building AI Agents</title>
<description>The world of AI development is moving fast, but building real, production-ready AI agents doesn’t have to be complex.
This series walks you step by step through how to design, build, and deploy AI agents using BoxLang AI. Whether you’re exploring AI for the first time or looking to modernize your current applications, these guides will help you move from concept to implementation with clarity.
Start Here: A Practical Overview
If you’re new to BoxLang AI or want to understand what’s possible before diving into the technical details, start here:
https://www.ortussolutions.com/blog/how-to-develop-ai-agents-using-boxlang-ai-a-practical-guide
This guide provides a high-level view of how to build AI agents, integrate multiple models, and design real-world workflows using BoxLang.
The Full Series
Follow the series in order to go from fundamentals to advanced implementations:
Part 1
https://www.ortussolutions.com/blog/boxlang-ai-deep-dive-part-1-of-7-the-skills-revolution
Part 2
https://www.ortussolutions.com/blog/boxlang-ai-deep-dive-part-2-of-7-building-a-production-grade-ai-tool-ecosystem
Part 3
https://www.ortussolutions.com/blog/boxlang-ai-deep-dive-part-3-of-7-multi-agent-orchestration-building-ai-teams-that-work
Part 4
https://www.ortussolutions.com/blog/boxlang-ai-deep-dive-part-4-of-7-middleware-the-missing-layer-in-every-ai-framework
Part 5
https://www.ortussolutions.com/blog/boxlang-ai-deep-dive-part-5-of-7-one-api-17-providers-the-provider-architecture-deep-dive
Part 6
https://www.ortussolutions.com/blog/boxlang-ai-deep-dive-part-6-of-7-memory-systems-rag-building-ai-that-remembers
Part 7
https://www.ortussolutions.com/blog/boxlang-ai-deep-dive-part-7-of-7-mcp-the-protocol-that-connects-everything
What You’ll Learn
Across this series, you’ll learn how to:
Build AI agents with memory, tools, and reasoning capabilities
Connect to multiple AI providers with a single unified API
Implement Retrieval-Augmented Generation (RAG) pipelines
Work with vector databases and document ingestion
Design scalable, production-ready AI workflows
Deploy AI agents in modern cloud environments
Key Resources
To help you go deeper and start building right away:
BoxLang AI Playgroundhttps://ai.boxlang.io/
Official BoxLang AI Documentationhttps://ai.ortusbooks.com/
BoxLang Websitehttps://boxlang.io/
GitHub Examples and Integrationshttps://github.com/ortus-boxlang
Why BoxLang AI
BoxLang AI is designed to remove the complexity of working with multiple AI providers and tools. With a single API, you can build powerful AI-driven applications without vendor lock-in, while maintaining full control over your architecture.
If you’re working with legacy systems, BoxLang also allows you to introduce AI capabilities incrementally without needing a full rewrite.
Ready to Start Building?
Explore the series, try the examples, and start building your own AI agents today.
If you have questions or want to see how this can apply to your existing systems, feel free to reach out to the Ortus team.
Next →</description>
<link>https://www.ortussolutions.com/blog/boxlang-ai-series-complete-guide-to-building-ai-agents</link>
<pubDate>Mon, 13 Apr 2026 09:45:00 GMT</pubDate>
<author>cristobal@ortussolutions.com (Cristobal Escobar)</author>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/boxlang-ai-series-complete-guide-to-building-ai-agents</guid>
</item>
<item>
<title>BoxLang Goes Serverless on Google Cloud &#128640;</title>
<description>We just shipped the BoxLang Google Cloud Functions Runtime — and it brings the same
write-once-run-anywhere serverless experience you already know from our AWS Lambda runtime,
now running natively on Google Cloud Functions Gen2.</description>
<link>https://www.ortussolutions.com/blog/boxlang-goes-serverless-on-google-cloud</link>
<pubDate>Thu, 09 Apr 2026 11:26:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>Community</category>
<category>Into The Box</category>
<category>News</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/boxlang-goes-serverless-on-google-cloud</guid>
</item>
<item>
<title>Introducing BoxLings! An interactive teacher for BoxLang and TDD/BDD</title>
<description>We believe the best way to learn a programming language is by writing code — real code, with real feedback, and real tests. That's exactly why we built BoxLings.</description>
<link>https://www.ortussolutions.com/blog/introducing-boxlings-an-interactive-teacher-for-boxlang-and-tddbdd</link>
<pubDate>Wed, 08 Apr 2026 14:06:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>Community</category>
<category>Into The Box</category>
<category>News</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/introducing-boxlings-an-interactive-teacher-for-boxlang-and-tddbdd</guid>
</item>
<item>
<title>BoxLang v1.12.0 - Destructuring, Spread, Ranges, Watchers, Oh My!</title>
<description>BoxLang 1.12.0 marks a meaningful turning point. After establishing a rock-solid foundation across runtime, compiler, CFML compatibility, and the module ecosystem, BoxLang has entered its innovation cycle. The language is mature, battle-tested, and production-deployed across the industry.</description>
<link>https://www.ortussolutions.com/blog/boxlang-v1120-destructuring-spread-ranges-watchers-oh-my</link>
<pubDate>Wed, 08 Apr 2026 11:08:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>Community</category>
<category>Into The Box</category>
<category>News</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/boxlang-v1120-destructuring-spread-ranges-watchers-oh-my</guid>
</item>
<item>
<title>The Loneliness of CTO Leadership: How to Make Important Decisions with Confidence</title>
<description>Being a CTO can be surprisingly isolated.
Not because of the title, but because of the decisions.
Every day, you’re expected to make calls that impact system stability, performance, security, team productivity, and long term costs. And often, you’re making those decisions with incomplete information, limited resources, and no real sounding board.
That’s where the real challenge begins.
It’s Not a Talent Problem, It’s a Context Problem
Most CTOs don’t struggle because their teams lack capability.
They struggle because they lack context and perspective.
Your internal team knows your system well, but they may not have seen how similar architectures fail under load, how other teams structure their environments, what patterns actually scale in production, or what decisions tend to create long term technical debt.
And when you’re the one responsible for the final call, there’s often no one to pressure test your thinking.
The Reality, Firefighting, Trade offs, and Limited Time
In many organizations, the day to day reality looks like this.
Production issues interrupt planned work, performance problems appear without clear root causes, security concerns are addressed reactively, and roadmaps compete with operational demands.
At the same time, you’re balancing limited budget, limited headcount, business expectations, and delivery timelines.
So decisions get made under pressure.
Not because they’re ideal, but because they’re necessary.
You Don’t Need More People, You Need Better Decisions
This is where many organizations go in the wrong direction.
They assume the solution is to hire more developers or bring in large external teams.
But more people doesn’t automatically mean better outcomes.
What actually changes the trajectory of a system is better prioritization, better architectural decisions, better understanding of trade offs, and better timing on when to act, and when not to.
In other words, you need an additional layer of experience, not necessarily more execution.
A Different Model, An Extension of Your Thinking
Instead of fully outsourcing or over hiring, some CTOs are adopting a more flexible approach.
They work with experienced partners not as vendors, but as an extension of their decision making process.
Think of it as having an extra brain.
Someone who helps validate architectural choices, identify risks early, prioritize what actually matters, and bring perspective from other real world environments.
Importantly, this doesn’t mean giving up control.
You decide how involved they are, what areas they support, and what gets implemented and when.
The goal is not to replace your team.
It’s to strengthen your ability to lead it.
What This Looks Like in Practice
A lightweight support or consulting relationship can provide value in ways that go far beyond incident resolution.
For example, reviewing your current architecture and identifying hidden risks, helping define a realistic and phased technical roadmap, prioritizing improvements based on impact instead of urgency, aligning infrastructure and environments, and reducing unnecessary complexity and cost.
This kind of support helps turn reactive decision making into structured progress.
Managing Systems as an Ongoing Operational Responsibility, Planning Ahead and Aligning with Leadership
One of the most valuable mindset shifts is recognizing that your systems are not just projects, they are operational assets.
They require continuous evaluation, incremental improvement, and ongoing alignment with business goals, but also forward planning and the ability to clearly communicate those plans at the leadership level.
Many CTOs are not only responsible for making the right technical decisions, but also for framing those decisions in a way that resonates with executive leadership, translating technical needs into business priorities, timelines, and outcomes.
Trying to solve everything in a single large initiative is rarely sustainable, and often difficult to justify internally without a clear roadmap.
Instead, many teams see better results by working within controlled monthly efforts, planning ahead, addressing technical debt gradually, and improving stability step by step, while having the right support to help shape, validate, and communicate those plans effectively.
This approach reduces risk, improves predictability, strengthens alignment with leadership, and makes better use of available resources.
You Don’t Have to Figure It Out Alone
Being a CTO doesn’t mean having all the answers.
It means making the best possible decisions with the information available.
But there’s no reason those decisions need to be made in isolation.
Whether it’s validating an approach, designing a roadmap, prioritizing limited resources, or simply having a second opinion, having the right partner in the background can make a meaningful difference.
Final Thought
Most systems don’t become unstable overnight.
They evolve that way through small decisions made over time.
The same is true for stability, scalability, and efficiency, they are built gradually, with the right guidance.
If you’re navigating these kinds of decisions, having the right support in the background can make a meaningful difference.
Many teams we work with don’t need a full external team, they need ongoing guidance, a second perspective, and access to experienced engineers when it matters most.
That’s exactly how we structure our support and consulting plans at Ortus, as a flexible way to accompany your team, help you prioritize, validate decisions, and step in when needed, without adding unnecessary overhead.
There’s a significant difference between solving problems in one system and solving them across hundreds.
At Ortus, we have a combined ColdFusion experience of over 300 years across our team of 30 engineers worldwide. Some of our team members have been working with ColdFusion since version 1.
We’ve been contributing to the open source CFML community since 2006, building and maintaining many of the tools that developers rely on every day, including ColdBox and CommandBox.
That exposure means we’ve seen what works, what fails, what scales, and what creates long term risk.
And that perspective is often what helps CTOs make more confident decisions.
If that kind of support sounds useful, we’re always open to a conversation.
</description>
<link>https://www.ortussolutions.com/blog/the-loneliness-of-cto-leadership-how-to-make-important-decisions-with-confidence</link>
<pubDate>Tue, 07 Apr 2026 09:52:00 GMT</pubDate>
<author>cristobal@ortussolutions.com (Cristobal Escobar)</author>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/the-loneliness-of-cto-leadership-how-to-make-important-decisions-with-confidence</guid>
</item>
<item>
<title>How to Develop AI Agents Using BoxLang AI: A Practical Guide</title>
<description>AI agents are transforming how we build software. Unlike traditional chatbots that just answer questions, agents can reason about what tools they need, decide when to use them, chain multiple actions together, and remember what happened earlier in a conversation.</description>
<link>https://www.ortussolutions.com/blog/how-to-develop-ai-agents-using-boxlang-ai-a-practical-guide</link>
<pubDate>Fri, 03 Apr 2026 21:28:00 GMT</pubDate>
<author>lmajano@ortussolutions.com (Luis Majano)</author>
<category>BoxLang</category>
<category>Community</category>
<category>Into The Box</category>
<category>News</category>
<category>Releases</category>
<guid isPermaLink="false">https://www.ortussolutions.com/blog/how-to-develop-ai-agents-using-boxlang-ai-a-practical-guide</guid>
</item>
</channel>
</rss>
