Tag:

agents

Business

GitLab 19.0: Integrating Agentic AI into Security and DevOps

by Chief Editor
written by Chief Editor

GitLab 19.0 marks a strategic pivot in software development, shifting agentic AI from simple code generation toward automated security, credential management, and lifecycle governance. By integrating features like the GitLab Secrets Manager and Developer Flow directly into the CI/CD pipeline, the platform aims to address the growing gap between AI-driven coding speed and the necessity for enterprise-grade security, according to company documentation released May 21.

How is AI changing the software development lifecycle?

The transition to agentic workflows means AI now manages the environment surrounding the code rather than just the syntax within it. GitLab 19.0 introduces Developer Flow, which automates merge request (MR) tasks such as addressing reviewer feedback, splitting large files, and resolving conflicts. According to GitLab, these agents consult an AGENTS.md file to ensure output aligns with specific team standards rather than generic defaults. This shift mirrors moves by competitors like GitHub Copilot and Atlassian Rovo, which are also racing to embed governance directly into the developer’s workspace.

How is AI changing the software development lifecycle?
Pro Tip: Use the AGENTS.md file to enforce team-specific coding styles. This prevents AI from defaulting to generic patterns that might conflict with your organization’s established architecture.

Why is centralized secrets management a security priority?

Managing credentials has historically required external tools, but GitLab 19.0 introduces a public beta of its own Secrets Manager to unify this process. By keeping secrets within the same platform that executes pipelines, GitLab allows teams to restrict credentials to specific authorized jobs. According to company product documentation, this setup enables responders to trace exactly which jobs accessed a specific credential during a compromise. The tool integrates with existing services like HashiCorp Vault, AWS Secrets Manager, and Google Cloud Secret Manager rather than forcing a total migration.

What does the shift to usage-based billing mean for teams?

GitLab is transitioning its Duo Core features to a usage-based model, signaling a broader industry move toward consumption-based pricing for AI tools. Code Suggestions in both Web and desktop IDEs now require GitLab Credits to function. Additionally, GitLab Duo Chat is becoming an agent-based service that requires teams to enable the GitLab Duo Agent Platform. Manav Khurana, GitLab’s chief product and marketing officer, noted that while AI accelerated code production, it complicated the trust and security required to scale, making these governance-focused changes necessary for enterprise adoption.

19.0 – GitLab Product Update in Japanese
Did you know? GitLab 19.0 now supports air-gapped environments by allowing self-hosted teams to run open-source models like Mistral Devstral 2 123B and GLM-5.1 directly through the Duo Agent Platform.

How does SBOM scanning improve supply chain security?

Software Bill of Materials (SBOM) dependency scanning is now generally available, providing visibility into vulnerabilities across ecosystems like Maven, npm, and PyPI. The platform automatically generates lockfiles and dependency graphs if they are missing from a project. By moving security configuration profiles to a policy-based model, platform engineers can enforce Secret Detection and SAST across an entire organization without needing to update individual project CI files, according to the release notes.

How does SBOM scanning improve supply chain security?

Frequently Asked Questions

  • Does GitLab 19.0 replace third-party vault services? No. GitLab Secrets Manager is designed to work alongside existing providers like AWS Secrets Manager and HashiCorp Vault.
  • What happens to existing CI/CD configurations? The update introduces policy-based security, allowing teams to set global rules for SAST and dependency scanning that override individual project settings.
  • Are there new platform requirements? Yes. GitLab 19.0 requires PostgreSQL 17, ends support for Redis 6, and drops support for Ubuntu 20.04.

Stay ahead of the latest DevOps trends and security updates. Subscribe to our newsletter for weekly insights on platform engineering and AI governance.

0 comments
0 FacebookTwitterPinterestEmail
Business

Orbio Raises $21M to Automate Frontline Hiring and Onboarding

by Chief Editor
written by Chief Editor

Orbio, an enterprise startup founded by Sergi Bastardas, Nacho Travesí, and Antonio Melé, secured $21 million in Series A funding led by Dawn Capital to automate frontline workforce management. The company, which uses AI agents to handle recruiting and daily employee operations, has raised $26 million total to date to support clients including YUM! Brands and The Stepping Stones Group.

How AI Agents Are Replacing Manual Workforce Management

Frontline management historically relies on fragmented processes like spreadsheets and manual phone calls, according to founder Sergi Bastardas. Orbio’s software replaces these manual tasks with AI agents—named Maria, Daniel, and Claire—that conduct interviews, assess candidate fit, and perform daily check-ins. By automating these touchpoints, the platform creates a feedback loop where onboarding data informs future recruiting criteria and engagement metrics highlight retention risks. At The Stepping Stones Group, this transition to autonomous management resulted in a 20% increase in successful candidate hires, as reported by the company.

Did you know?
Most of the 2.7 billion workers in retail, logistics, and hospitality roles do not have corporate email addresses, making them difficult to reach through traditional HR software.

How Does Orbio Compare to Existing HR Tech?

The frontline HR technology market features several established players with varying focuses. While Orbio targets the end-to-end lifecycle of frontline workers, competitors like Paradox specialize in automating the recruiting and hiring funnel. Meanwhile, companies such as WorkJam provide digital workspaces for frontline employees to manage their own shifts and communications. Bastardas notes that Orbio’s primary competition is not these software vendors, but the legacy reliance on manual, paper-based, or spreadsheet-heavy processes that remain standard in healthcare and logistics.

What Are the Long-Term Trends for Frontline Workers?

The industry is moving toward “human infrastructure” that treats frontline workers as a digitally connected workforce. Bastardas argues that this represents an “AI moment” for the billions of employees who have previously lacked access to sophisticated corporate tools. Future development will focus on scaling these AI agents to handle more complex operational tasks, as Orbio plans to use its latest funding to expand its agent capabilities. Businesses are shifting from pilot programs to full deployment, indicating that autonomous management is moving from an experimental phase to an operational standard.

Pro Tip:
When evaluating AI-driven workforce tools, prioritize platforms that offer integrated data loops—where hiring feedback directly informs retention strategy—rather than standalone automation for single tasks.

Frequently Asked Questions

What specific companies use Orbio?

Orbio’s current client list includes major entities such as YUM! Brands, which owns KFC, Taco Bell, and Pizza Hut, as well as the healthcare provider The Stepping Stones Group.

Staffing Insights: Automated Workforce Management

How much funding has Orbio raised?

As of 2025, Orbio has raised a total of $26 million in funding, including a $21 million Series A round led by Dawn Capital and contributions from investors like Visionaries and 2100 Ventures.

What do Orbio’s AI agents actually do?

The agents conduct candidate interviews, assess job fit, monitor employee output, and facilitate daily check-ins throughout the worker’s tenure to manage operations autonomously.

Are you seeing AI integration changing your daily operations? Share your thoughts in the comments below or subscribe to our newsletter for more updates on the evolution of enterprise technology.

0 comments
0 FacebookTwitterPinterestEmail
Tech

Gemma 2 12B: Enabling On-Device Multimodal Agentic Workflows

by Chief Editor
written by Chief Editor

Gemma 4 12B is a new, encoder-free multimodal model designed to run agentic, intelligent workflows directly on local laptops. By eliminating traditional multi-stage vision and audio encoders, the model allows for faster, more efficient processing of multimodal inputs on consumer-grade hardware, according to technical documentation released in June 2026.

How does the encoder-free architecture improve local AI?

Traditional multimodal models rely on separate, heavy encoders for vision and audio, which creates latency and increases memory usage. Gemma 4 12B bypasses this by feeding multimodal data directly into the LLM backbone, using a single decoder-only transformer. This architecture mirrors the advanced structure found in the 31B Dense model, enabling a reduced memory footprint that fits on devices with 16GB of VRAM or unified memory.

How does the encoder-free architecture improve local AI?

The system handles visual data by using a 35M-parameter vision embedder that projects 48×48 pixel patches directly into the LLM’s hidden space. For audio, the model skips separate encoders entirely. Instead, it slices 16 kHz audio into 40 ms frames and projects them linearly into the input space, a shift that simplifies fine-tuning processes for developers.

What can you build with Gemma 4 12B?

Developers are using the model to execute scripts and generate code on the fly. Through the Google AI Edge Gallery app, users can turn natural language instructions into functional programs. One demonstration showcased the model creating a Python script to render a PNG chart comparing girl names from 2024 and 2025.

The model’s utility extends to various developer environments. It supports integration with tools like LiteRT-LM, which allows for the launch of OpenAI-compatible servers using the litert-lm serve command. It is also compatible with llama.cpp, Hugging Face, Ollama, and LM Studio, providing flexibility for local deployment.

Pro Tip: If you are looking for a deep technical analysis of the model’s structure, Maarten Grootendorst has published a detailed visual guide exploring the architecture and implementation of Gemma 4 12B.

What are users saying about performance?

Early feedback from the developer community on Reddit highlights a mix of excitement and practical testing. User LoveMind_AI noted that the encoder-free design is a significant development for local models, specifically praising the inclusion of native audio. Another user, few, reported success using the model to build a full-stack Python application with a server and client side, noting the model’s effective handling of long-context tasks.

From Instagram — related to Hugging Face, Google Cloud

However, performance expectations vary by task. User triynizzles suggested that while the model excels at explaining code paths and fixing logic bugs, it may struggle with more ambiguous, complex tasks compared to larger models like Qwen 3.6. These real-world accounts suggest that while the 12B model is a powerful tool for localized agentic workflows, its output quality remains task-dependent.

Frequently Asked Questions

  • Does Gemma 4 12B require a high-end server? No. It is designed to run locally on laptops equipped with 16GB of VRAM or unified memory.
  • Can it process audio natively? Yes. It is the first medium-sized model in the Gemma family capable of native audio ingestion without a separate encoder.
  • Where can I download the model? It is available through platforms including Hugging Face, Ollama, LM Studio, and Google Cloud.

Ready to start building?

Explore the Google AI Edge Gallery to see how you can deploy these workflows on your own machine. Have you experimented with Gemma 4 12B yet? Share your findings or questions in the comments below.

NEW Google Gemma 4 12B AI Update 🤯

0 comments
0 FacebookTwitterPinterestEmail
Tech

Google LiteRT-LM Boosts Gemma 4 Inference Speed by 2.2x

by Chief Editor
written by Chief Editor

The Future of On-Device AI: Why LiteRT-LM Changes Everything

For years, the promise of Artificial Intelligence has been shackled to the cloud. We’ve relied on massive server farms to process even the simplest queries, sacrificing privacy and speed for the sake of model size. However, the release of LiteRT-LM—the evolution of TensorFlow Lite—marks a definitive shift toward a “local-first” AI future.

By bringing native support for Gemma 4 Multi-Token Prediction (MTP) directly to mobile and edge hardware, developers can now achieve inference speeds up to 2.2x faster than previous iterations. This isn’t just an incremental update; it’s a fundamental rethinking of how Large Language Models (LLMs) interact with our devices.

Pro Tip: If you’re building mobile AI applications, prioritize hardware-accelerated kernels like XNNPACK. By keeping your KV cache and activations on the GPU, you can eliminate the latency bottlenecks caused by cross-IP data transfers.

Breaking the Latency Barrier with Speculative Decoding

The biggest hurdle for on-device LLMs has always been the “stutter”—the delay between a prompt and the generated output. LiteRT-LM tackles this through a specialized orchestration layer that enforces memory locality. By running both the primary model and the MTP drafter on the same hardware IP, the system avoids the costly penalties of moving data back and forth.

According to recent benchmarks, this architecture delivers remarkable performance gains:

  • Gemma 4 E2B: 1.6x faster decoding.
  • Gemma 4 E4B: 2.2x faster decoding.
  • Competitive Edge: 1.8x to 3.7x faster performance compared to frameworks like llama.cpp and ONNX.

Efficiency as a Competitive Advantage

High performance is meaningless if it drains your battery or hogs all your RAM. LiteRT-LM addresses this by treating memory efficiency as a first-class citizen. By dynamically loading image and audio encoders only when they are needed and keeping per-layer embeddings out of memory, the runtime remains incredibly lean.

Consider this: a ~2.58GB model can now function with a footprint of just 607MB on Apple mobile CPUs. This level of optimization ensures that sophisticated, agentic AI can run in the background without impacting the user’s ability to run other apps.

Did you know? LiteRT-LM allows for “Thinking Mode” and native function-calling. This means your phone’s AI can pause, handle a structured tool request, and resume execution seamlessly—bringing us one step closer to truly autonomous, helpful digital agents.

The Road Ahead: Agentic Capabilities and Beyond

The future of on-device AI isn’t just about faster text generation; it’s about agentic workflows. With native support for constrained decoding and function-calling, LiteRT-LM is paving the way for apps that can proactively manage tasks. Imagine a device that manages your calendar, processes sensitive financial data locally, and interacts with other apps—all without sending a single byte of data to a central server.

Gemma 4 12B – Google's Unified Multimodal Model Running Locally

As the framework expands its reach to Swift and JavaScript APIs, the barrier to entry for developers is falling. Whether you are working on Android, iOS, or web-based projects, the tools to build high-performance, private AI are now readily available on GitHub.

Frequently Asked Questions (FAQ)

What is the primary benefit of LiteRT-LM for mobile developers?

LiteRT-LM provides a highly optimized runtime that enables native support for Gemma 4, allowing for significantly faster inference speeds (up to 2.2x) and a reduced memory footprint on mobile devices.

Frequently Asked Questions (FAQ)
Token Prediction

Does LiteRT-LM require a cloud connection?

No. LiteRT-LM is designed specifically for on-device inference, allowing models to run locally on your hardware. This improves user privacy and ensures functionality even without an internet connection.

How does LiteRT-LM handle multi-token prediction?

It uses speculative decoding, where a lightweight “drafter” model predicts future tokens. These are verified by the primary model in a single pass, which significantly reduces the data movement between VRAM and compute units.

Can I use LiteRT-LM for complex agentic tasks?

Yes. The framework includes native support for function-calling and “Thinking Mode,” which allows models to handle structured outputs and pause/resume execution for tool-based interactions.

Are you experimenting with on-device LLMs? Share your experience with LiteRT-LM in the comments below, or subscribe to our newsletter for deep dives into the latest edge computing trends.

0 comments
0 FacebookTwitterPinterestEmail
Tech

How Slack Manages Context in Long-running Multi-agent Systems

by Chief Editor
written by Chief Editor

Beyond the Chat Log: The Evolution of AI Memory

For a long time, the standard approach to maintaining “memory” in AI agents was simple: preserve a running log of the conversation. As the user and the AI exchanged messages, the system would simply feed the entire history back into the model with every new request. While this works for a quick Q&amp. A session, it fails spectacularly in complex, long-running enterprise workflows.

Beyond the Chat Log: The Evolution of AI Memory
Chat Critics The Evolution

The problem is the “context window”—the hard limit on how much information an LLM can process at once. When a session spans hundreds of requests and generates megabytes of output, the history doesn’t just fill the window; it degrades the quality of the responses. We are seeing a fundamental shift from linear chat logs to structured memory.

Did you know? Approaching an agent’s context window limit doesn’t just stop the AI from “remembering” the start of the chat—it can actually degrade the overall reasoning quality and accuracy of the responses.

The future of AI isn’t about larger context windows, but about smarter context management. By using distilled truth and structured summaries, agents can maintain coherence over vast amounts of data without getting “lost” in the noise of a raw transcript.

The Architecture of Truth: Why “Critics” are the New Essential

One of the most significant trends in multi-agent design is the separation of execution from validation. In traditional setups, a single agent is expected to find the answer and ensure We see correct. In more sophisticated systems, such as those implemented by Slack, a “coordinator/dispatcher” model is used.

In this model, specialized agents handle specific tasks, but a dedicated Critic agent acts as a truth filter. This is crucial because, as observed in complex AI deployments, expert findings “could either be invented or grossly misinterpret the data.”

How the Validation Loop Works

  • Expert Agents: Gather data and generate initial findings.
  • Critic Agents: Review summary reports and use evidence inspection tools to assign credibility scores.
  • Strict Guardrails: To prevent the Critic itself from hallucinating, it is narrowly instructed to “only craft a judgement on the submitted findings.”

This trend toward “adversarial” internal checks ensures that only corroborated, high-credibility information makes it into the final output, effectively scrubbing hallucinations before they reach the end user.

Slack Native Multi-Agent Todo System

Scaling Complex Workflows: The Coordinator-Dispatcher Model

As we move toward more autonomous AI “workforces,” the industry is moving away from monolithic agents toward a hierarchical structure. This is best exemplified by the use of a central coordinator that manages a team of experts and critics.

To keep this team aligned, the system requires a shared source of truth. Instead of sharing the whole chat history, these systems use complementary context channels to maintain a “common narrative.”

The three essential channels for long-term coherence:

  1. The Director’s Journal: A structured working memory containing decisions, hypotheses, and observations. This “provides the common narrative that keeps other agents on track.”
  2. The Critic’s Review: A credibility-weighted list of findings based on evidence.
  3. The Critic’s Timeline: A distilled, chronological narrative that resolves conflicts by preferring the strongest sources and removing duplicates.

By separating these streams, the Director can make strategic decisions, Experts can build on established understanding, and Critics can evaluate findings objectively—all without overloading the LLM’s memory.

Pro Tip: If you are building agentic workflows, stop passing the full history array to your LLM. Start implementing a “summary” or “state” object that is updated at the end of each turn. This reduces token costs and increases reliability.

The Future of Agentic Reasoning: Distilled Truth vs. Raw Data

The broader principle emerging here is the move toward distilled truth. In the next generation of AI applications, the goal will not be to provide the AI with all the data, but to provide it with the right structured summary.

The Future of Agentic Reasoning: Distilled Truth vs. Raw Data
Chat Slack

We can expect to see this evolve into dynamic memory systems that automatically prune irrelevant information and prioritize “high-credibility” nodes of information. This allows an AI application to handle megabytes of output and hundreds of requests while remaining as sharp and focused as it was during the first prompt.

For those interested in the technical implementation of these patterns, exploring Slack’s approach to agentic applications provides a blueprint for moving from simple chatbots to robust, long-running AI systems.

Frequently Asked Questions

What is a context window in AI?
The context window is the maximum amount of text (tokens) an LLM can process in a single request. Once this limit is reached, the model begins to “forget” earlier parts of the conversation or may experience a drop in reasoning quality.

How does structured memory differ from chat history?
Chat history is a raw, linear log of every message exchanged. Structured memory is a curated set of summaries, decisions, and validated facts (like a journal or timeline) that capture the essence of the conversation without the bulk.

What is a Critic agent?
A Critic agent is a specialized AI role designed to validate the work of other agents. It inspects evidence and assigns credibility scores to findings to filter out hallucinations and errors.

What do you think? Is the “Critic” model the best way to solve AI hallucinations, or should we be focusing on larger context windows? Let us know in the comments below or subscribe to our newsletter for more deep dives into the future of AI engineering!

0 comments
0 FacebookTwitterPinterestEmail
Tech

Stripe Engineers Deploy Minions, Autonomous Agents Producing Thousands of Pull Requests Weekly

by Chief Editor
written by Chief Editor

Stripe’s ‘Minions’ Signal a Modern Era of AI-Powered Coding

Engineers at Stripe have quietly launched a revolution in software development: autonomous coding agents dubbed “Minions.” These aren’t the yellow, banana-loving creatures, but sophisticated AI systems capable of generating production-ready pull requests with minimal human intervention. The implications for developer productivity and the future of coding are significant.

From Concept to 1,300 Pull Requests a Week

The Minions project began as an internal fork of Goose, a coding agent developed by Block. Stripe customized Goose for its specific LLM infrastructure and refined it to meet the demands of a large-scale payment processing system. The results are impressive. Currently, Minions generate over 1,300 pull requests per week, a figure that has climbed from 1,000 during initial trials. Crucially, all changes are reviewed by human engineers, ensuring quality and security.

This isn’t about replacing developers; it’s about augmenting their capabilities. The Minions handle tasks like configuration adjustments, dependency upgrades, and minor refactoring – the often-tedious but essential function that can consume a significant portion of a developer’s time.

One-Shot Agents: A Different Approach to AI Coding

What sets Minions apart from popular AI coding assistants like GitHub Copilot or Cursor? Minions operate on a “one-shot” basis, completing end-to-end tasks from a single instruction. Tasks can originate from various sources – Slack threads, bug reports, or feature requests – and are then orchestrated using “blueprints.” These blueprints combine deterministic code with flexible agent loops, allowing the system to adapt to different requirements.

This contrasts with interactive tools that require constant human guidance. Minions are designed to take a task description and deliver a complete, tested, and documented solution, ready for review.

Handling Complexity at Scale: $1 Trillion in Payments

The stakes are high. The code managed by Minions supports over $1 trillion in annual payment volume at Stripe. This means reliability and correctness are paramount. The system operates within a complex web of dependencies, navigating financial regulations and compliance obligations. Stripe reinforces reliability through robust CI/CD pipelines, automated tests, and static analysis.

Did you recognize? Stripe’s Minions are not just theoretical; they are actively managing critical infrastructure for a global payments leader.

The Rise of Agent-Driven Software Development

Stripe’s Minions are part of a broader trend toward agent-driven software development. LLM-based agents are becoming increasingly integrated with development environments, version control systems, and CI/CD pipelines. This integration promises to dramatically increase developer productivity while maintaining strict quality controls.

The key to success, according to Stripe engineers, lies in carefully defining tasks and utilizing blueprints to guide the agents. Blueprints act as a framework, weaving together agent skills with deterministic code to ensure both efficiency and adaptability.

Future Trends: What’s Next for AI Coding Agents?

The success of Minions suggests several potential future trends:

  • Increased Task Complexity: As agents become more sophisticated, they will be able to handle increasingly complex tasks, potentially automating entire features or modules.
  • Self-Improving Agents: Agents may learn from their successes and failures, continuously improving their performance and reducing the need for human intervention.
  • Domain-Specific Agents: We can expect to see the development of specialized agents tailored to specific industries or programming languages.
  • Enhanced Blueprinting Tools: Tools for creating and managing blueprints will become more user-friendly and powerful, allowing developers to easily define and orchestrate complex tasks.

FAQ

Q: Will AI coding agents replace developers?
A: No, the current focus is on augmenting developer productivity, not replacing developers entirely. Human review remains a critical part of the process.

Q: What are “blueprints” in the context of Stripe’s Minions?
A: Blueprints are workflows defined in code that specify how tasks are divided into subtasks and handled by either deterministic routines or the agent.

Q: How does Stripe ensure the reliability of code generated by Minions?
A: Stripe uses CI/CD pipelines, automated tests, and static analysis to ensure generated changes meet engineering standards before human review.

Q: What types of tasks are Minions best suited for?
A: Minions perform best on well-defined tasks such as configuration adjustments, dependency upgrades, and minor refactoring.

Pro Tip: Explore the Stripe developer blog for more in-depth technical details about the Minions project: https://stripe.dev/blog/minions-stripes-one-shot-end-to-end-coding-agents

What are your thoughts on the future of AI-powered coding? Share your insights in the comments below!

0 comments
0 FacebookTwitterPinterestEmail
Tech

AWS Launches Strands Labs for Experimental AI Agent Projects

by Chief Editor
written by Chief Editor

AWS Unveils Strands Labs: A Playground for the Future of AI Agents

Amazon Web Services (AWS) has launched Strands Labs, a new GitHub organization dedicated to experimental AI agent development. This move signals a significant investment in the rapidly evolving field of agentic AI, offering developers a sandbox to explore cutting-edge approaches beyond the constraints of production-ready software.

Robots Accept Center Stage: Bridging the Physical and Digital Worlds

A core focus of Strands Labs is robotics. The Strands Robots project aims to connect AI agents directly with physical hardware. This isn’t about remote control; it’s about agents that can perceive their environment, interpret instructions, and take action autonomously. Demonstrations showcase an agent controlling an SO-101 robotic arm using the NVIDIA GR00T model, a vision-language-action (VLA) model.

The integration with LeRobot further simplifies the process of interacting with robotics hardware and datasets. This combination allows developers to build agents capable of processing visual data, understanding commands, and performing physical tasks – a crucial step towards more versatile and adaptable robots.

Simulation as a Stepping Stone: The Power of Strands Robots Sim

Recognizing the challenges of working directly with physical robots, Strands Labs also offers Strands Robots Sim. This project provides a simulation environment where developers can test and refine their agents without the risks and costs associated with real-world hardware. The simulator supports environments from the Libero robotics benchmark and integrates VLA policies, allowing for iterative experimentation and debugging.

Pro Tip: Simulation environments are invaluable for rapid prototyping and testing different agent behaviors before deploying them to physical robots. This significantly reduces development time and potential damage to hardware.

AI Functions: A New Paradigm for Software Development

Beyond robotics, Strands Labs is exploring innovative approaches to software development itself. The AI Functions project introduces a novel concept: defining function behavior using natural language descriptions and validation conditions. The @ai_function decorator then triggers the Strands agent loop to generate code that meets the specified criteria.

This “specification-driven programming” approach represents a potential shift in how software is created, allowing developers to focus on *what* they want a function to do, rather than *how* to implement it. The system automatically retries if validation fails, ensuring the generated code meets the defined requirements. The framework can generate code that performs tasks like parsing files and data transformations, returning standard Python objects.

Community Response and Future Implications

The launch of Strands Labs has generated excitement within the AI development community. Clare Liguori, Senior Principal Engineer at AWS, described Strands Labs as “a playground for the next generation of ideas for AI agent development.” Others have highlighted the potential of AI Functions to revolutionize software development workflows.

Did you know? The Strands Agents SDK, upon which Strands Labs builds, has already been downloaded over 14 million times since its open-source release in May 2025, demonstrating strong developer interest in agentic AI.

FAQ

What is Strands Labs? Strands Labs is a new GitHub organization from AWS dedicated to experimental AI agent development.

What are the key projects in Strands Labs? The initial projects are Robots, Robots Sim, and AI Functions.

What is the NVIDIA GR00T model? GR00T is a vision-language-action (VLA) model used to control robots based on visual input and language instructions.

What is specification-driven programming? It’s an approach where developers define the desired behavior of a function using natural language and validation rules, and an AI agent generates the code to implement it.

Explore the projects and contribute to the future of agentic AI at Strands Labs on GitHub.

0 comments
0 FacebookTwitterPinterestEmail
Tech

Microsoft Open Sources Evals for Agent Interop Starter Kit to Benchmark Enterprise AI Agents

by Chief Editor
written by Chief Editor

The Rise of Agent Interoperability: How Microsoft’s New Toolkit Signals the Future of AI

Microsoft’s recent release of Evals for Agent Interop isn’t just another developer tool; it’s a signpost pointing towards the next major evolution in artificial intelligence. The open-source starter kit is designed to aid organizations rigorously evaluate how well AI agents work together, a critical capability as businesses increasingly deploy multiple agents to automate complex tasks.

Beyond Individual Agent Performance: The Demand for Interoperability

For years, the focus in AI development has been on improving the performance of individual models. However, the real power of AI in enterprise settings lies in its ability to orchestrate a network of agents, each specializing in a specific function. These agents need to seamlessly hand off tasks, share information, and coordinate actions. Traditional testing methods, focused on isolated accuracy, simply aren’t equipped to assess this level of complexity.

As organizations build more autonomous agents powered by large language models, the challenges are growing. Agents behave probabilistically, integrate deeply with applications, and coordinate across tools, making isolated accuracy metrics insufficient for understanding real-world performance. What we have is why agent evaluation has turn into a critical discipline, particularly where agents impact business processes, compliance, and safety.

What Does Evals for Agent Interop Offer?

The starter kit provides a framework for systematic, reproducible evaluation. It includes curated scenarios, representative datasets, and an evaluation harness. Currently, the focus is on email and calendar interactions, but Microsoft plans to expand the kit with richer scoring capabilities and support for broader agent workflows. The kit utilizes templated, declarative evaluation specs (in JSON format) and measures signals like schema adherence and tool call correctness, alongside AI-powered assessments of qualities like coherence, and helpfulness.

A key component is the inclusion of a leaderboard, allowing organizations to benchmark their agents against “strawman” agents built using different stacks and model variants. This comparative insight helps identify failure modes early and develop informed decisions before widespread deployment.

The Architecture Behind the Scenes

The Evals for Agent Interop project is built on a three-part architecture: an API (backend) for managing test cases and agent evaluations, an Agent component serving as a reference implementation, and a Webapp (frontend) for creating, managing, and viewing results. It leverages Azure infrastructure, including Cosmos DB and Azure OpenAI, and can be deployed using a provided Bicep template. The kit is designed to be easily executed locally using Docker Compose.

Future Trends in Agent Evaluation

Microsoft’s initiative highlights several emerging trends in AI agent development:

  • Emphasis on Holistic Evaluation: The shift from evaluating individual models to assessing the performance of entire agent ecosystems.
  • The Rise of AI-Powered Judging: Utilizing AI models to evaluate the output of other AI models, providing scalable and consistent assessments.
  • Standardization of Evaluation Frameworks: The need for common benchmarks and metrics to facilitate comparison and progress in the field.
  • Increased Focus on Robustness and Resilience: Evaluating agents’ ability to handle unexpected inputs, errors, and changing conditions.
  • Integration with Enterprise Workflows: Testing agents in realistic scenarios that mirror actual business processes.

We can expect to observe more tools and platforms emerge that focus on these areas, enabling organizations to build and deploy AI agents with greater confidence and reliability.

Pro Tip

Don’t underestimate the importance of defining clear rubrics for evaluating agent performance. A well-defined rubric ensures consistency and objectivity in your assessments.

FAQ

Q: What is Evals for Agent Interop?
A: It’s an open-source starter kit from Microsoft designed to help evaluate how well AI agents work together.

Q: What platforms does it support?
A: Currently, it focuses on Microsoft 365 services like Email and Calendar, with plans to expand.

Q: Is it tough to get started?
A: The kit is designed to be simple to start with, and it can be deployed locally using Docker Compose.

Q: What is the leaderboard for?
A: The leaderboard allows organizations to compare the performance of their agents against others built using different technologies.

Q: What is the MCP server?
A: The MCP (Model Context Protocol) server is used for tool execution within the evaluation framework.

Did you know? Agent evaluation is becoming as vital as model training in the development of effective AI systems.

Ready to dive deeper into the world of AI agents? Explore the Evals for Agent Interop repository on GitHub and start evaluating your own agents today! Share your experiences and insights in the comments below.

0 comments
0 FacebookTwitterPinterestEmail
Sport

2026 CFL Free Agency: News & Updates

by Chief Editor
written by Chief Editor

CFL Free Agency Frenzy: A Day of Deals and a Changing League Landscape

CFL free agency officially opened today and the flurry of activity signals a pivotal moment for several teams. Even as the initial hours saw a steady stream of announcements, the most significant development revolves around the B.C. Lions and linebacker Maxime Rouyer. Rouyer’s recent designation as a National player, granted through a special exception by the CFL, dramatically alters his value and potential career trajectory.

The Rouyer Rule: A Game Changer for Canadian Talent

The CFL’s decision to allow Rouyer to change his status from Global to National is unprecedented. This move, aligning him with other U Sports alumni, effectively opens up roster spots for Canadian players and provides teams with greater flexibility in meeting ratio requirements. It’s a clear indication the league is prioritizing the development and retention of Canadian talent.

Ottawa’s Defensive Overhaul: A Bold Strategy

The Ottawa Redblacks are making a statement early in free agency, aggressively bolstering their defence with signings like C.J. Reavis and Demerio Houston. Reavis, a two-time All-CFL player, represents a significant upgrade at the strongside linebacker position. Houston’s addition further strengthens a secondary that has struggled in recent seasons. The Redblacks appear determined to address defensive weaknesses and contend in the East Division.

Winnipeg’s Strategic Additions: Building on a Championship Foundation

The Winnipeg Blue Bombers, consistently a powerhouse in the CFL, are making calculated moves to maintain their competitive edge. The signings of Jarell Broxton, Tommy Nield, and Jovan Santos-Knox demonstrate a commitment to both bolstering the offensive line and adding depth to the linebacker corps. Winnipeg’s ability to attract established players speaks to the organization’s stability and championship culture.

Edmonton’s Offensive Rebuild: A New Era in the North?

The Edmonton Elks are undergoing a significant offensive overhaul, securing commitments from several players previously with the Hamilton Tiger-Cats, including Taylor Powell, Joe Robustelli, and Brendan O’Leary-Orange. This influx of talent suggests a deliberate effort to revitalize the Elks’ offence and provide a more dynamic attack.

Hamilton’s Focus on Canadian Content and Special Teams

The Hamilton Tiger-Cats are prioritizing Canadian talent and special teams prowess. The signings of Kene Onyeka and Fraser Masin reflect this strategy. Masin, the first overall pick in the 2023 Global Draft, adds depth to the punting game, while Onyeka provides potential depth on the defensive line.

The Impact of Legal Tampering and Financial Flexibility

The pre-free agency legal tampering window has develop into a crucial period for player negotiations. Increased revenue sharing and the strategic utilize of marketing money provide teams with greater financial flexibility, allowing them to compete for top free agents. This has led to a more active and competitive market, with many agreements reached before the official opening of free agency.

Pro Tip

Keep a close eye on teams that are actively addressing ratio requirements. Canadian players are becoming increasingly valuable, and teams will often prioritize signing them to maintain roster balance.

Did You Know?

The CFL’s salary cap has increased significantly in recent years, giving teams more resources to pursue free agents. This increased financial flexibility is contributing to a more competitive free agency market.

FAQ: CFL Free Agency

Q: What is the CFL’s legal tampering window?
A: It’s a period before official free agency opens where teams can negotiate with pending free agents.

Q: What is a “National” player in the CFL?
A: A player who is a Canadian citizen and meets specific criteria related to their football background.

Q: What is a “Global” player in the CFL?
A: A player who is not a Canadian citizen but is eligible to play in the CFL under specific rules.

Q: How does the CFL salary cap work?
A: The CFL has a salary cap that limits the amount of money teams can spend on player salaries. The cap amount varies each year.

Q: What is the significance of the ratio rule?
A: The ratio rule requires teams to have a certain number of Canadian players on the field at all times.

Stay tuned to 3DownNation for continued coverage of CFL free agency. We’ll provide in-depth analysis, breaking news, and expert insights throughout the day.

0 comments
0 FacebookTwitterPinterestEmail
Business

Next Moca Releases Agent Definition Language as an Open Source Specification

by Chief Editor
written by Chief Editor

The Rise of Agent Definition Languages: A Fresh Standard for AI’s Future

The artificial intelligence landscape is rapidly evolving beyond simple chatbots and one-off prompts. We’re entering the era of AI agents – autonomous entities capable of reasoning, utilizing tools, accessing knowledge, and orchestrating complex workflows. But with this advancement comes a critical challenge: a lack of standardization. Every platform and team defines “agents” differently, leading to fragmentation and hindering scalability. Now, a new open-source standard, the Agent Definition Language (ADL), aims to solve this problem.

What is ADL and Why Does it Matter?

Developed by Next Moca and released under the Apache 2.0 license, ADL is essentially a blueprint for AI agents. It provides a vendor-neutral, declarative format for defining everything an agent *is* and *can do*. This includes its identity, purpose, the language model it uses, the tools it has access to, its permissions, how it accesses information (through Retrieval Augmented Generation or RAG), and even governance metadata like ownership and version history.

Think of it like this: OpenAPI defines APIs, allowing different systems to communicate seamlessly. ADL aims to do the same for AI agents. As Kiran Kashalkar, founder of Next Moca, puts it, ADL is “Think OpenAPI (Swagger) for agents.”

Addressing the Fragmentation Problem

Currently, agent definitions are often scattered across various formats – YAML files, code embedded configurations, proprietary JSON fields – making it difficult to understand an agent’s capabilities and boundaries. This lack of clarity poses significant challenges for security reviews, compliance, and reuse. ADL consolidates these definitions into a single, machine-readable format, enhancing inspectability and governance.

Pro Tip: A standardized definition layer like ADL allows for consistent validation in CI/CD pipelines, ensuring agents meet predefined standards before deployment.

How ADL Works: A Declarative Approach

ADL is a declarative language, meaning it focuses on *what* an agent should do, not *how* it should do it. It doesn’t define runtime behavior or agent-to-agent communication protocols. Instead, it provides a clear specification of the agent’s characteristics, allowing different platforms and frameworks to interpret and execute it.

This framework-agnostic approach is crucial for portability. Developers can define an agent once using ADL and then deploy it across various platforms without modification. This reduces vendor lock-in and promotes interoperability.

Beyond Definition: The Future of Agent Management

The release of ADL is just the beginning. The open-source nature of the project encourages community contributions and the development of an ecosystem of tools around the standard. This could include:

  • Editors: User-friendly interfaces for creating and managing ADL definitions.
  • Validators: Tools for ensuring ADL definitions are valid and conform to the specification.
  • Registries: Centralized repositories for storing and sharing ADL definitions.
  • Testing Tools: Automated tests for verifying agent behavior based on its ADL definition.

This ecosystem will streamline the entire agent lifecycle, from development and deployment to monitoring and maintenance.

ADL and Existing Technologies

ADL isn’t intended to replace existing technologies like A2A (agent-to-agent communication), MCP, OpenAPI, or workflow engines. Instead, it complements them. ADL defines the agent itself, while these other technologies handle communication, execution, and orchestration.

Did you know? ADL focuses on the “what” of an agent, while other technologies focus on the “how.”

Real-World Applications

The potential applications of ADL are vast. Consider these examples:

  • Customer Support: Defining agents that can handle specific customer inquiries, access knowledge bases, and escalate complex issues.
  • Fraud Detection: Creating agents that can analyze transactions, identify suspicious patterns, and flag potential fraud.
  • HR Automation: Developing agents that can automate tasks like onboarding, benefits administration, and employee inquiries.

In each of these scenarios, ADL provides a standardized way to define the agent’s capabilities, permissions, and governance policies.

Frequently Asked Questions (FAQ)

Q: Is ADL a runtime environment?
A: No, ADL is a definition language. It doesn’t execute code or manage agent workflows. It simply defines what an agent is and what it can do.

Q: Is ADL tied to a specific programming language?
A: No, ADL is model-agnostic and platform-agnostic. It’s based on JSON, a widely supported data format.

Q: How can I contribute to the ADL project?
A: The ADL repository on GitHub ([https://github.com/nextmoca/adl](https://github.com/nextmoca/adl)) provides contribution guidelines and a public roadmap.

Q: What are the benefits of using ADL?
A: Portability, auditability, vendor neutrality, and improved governance are key benefits.

The open-sourcing of ADL marks a significant step towards a more standardized and scalable future for AI agents. By providing a common language for defining these powerful entities, ADL empowers developers, enhances security, and unlocks new possibilities for innovation.

Explore the ADL project on GitHub: https://github.com/nextmoca/adl

0 comments
0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts