Datalayer

Nice write up about #Jupyter #MCP Server published on i-programmer.info by Nikos Vaggalis https://lnkd.in/e-PCywXv

🚀 FastA2A Finds a New Home at Datalayer We’re excited to share that Pydantic is donating the FastA2A open source repository to Datalayer. FastA2A has already benefited from strong collaboration between both teams — including recent work on streaming support and deeper A2A capabilities. As the ecosystem evolves, this transition ensures the project continues to grow with clear focus and momentum. While FastA2A is not a flagship component of Pydantic’s core roadmap (with initiatives like Logfire and Pydantic AI taking center stage), it has strong community interest and important potential in the agent-to-agent space. At Datalayer, we’ll take on stewardship of the project and evolve it in line with our priorities: - A2A (agent-to-agent) infrastructure - Generative UI (A2UI) - Jupyter-based execution sandboxes - Data-centric AI workflows We remain committed to: ✔️ keeping FastA2A MIT licensed ✔️ maintaining an open and community-driven development model ✔️ evolving the project based on real developer needs This is more than a transfer — it’s a continuation of a shared vision for open, composable AI systems. Looking forward to building the next phase of FastA2A together with the community 🤝. Kudos to Marcelo Trylesinski as core developer and innovator, and Laís Carvalho for making this transition possible. New 🏠 for FastA2A: https://lnkd.in/eGzhS3XR Read more: https://lnkd.in/eWsd-f3y

🔥 Clouder is now open source! Create, manage, and share Kubernetes clusters—effortlessly. Clouder is a CLI and Python package built to streamline how you interact with cloud services. Whether you're managing Kubernetes clusters, SSH keys, virtual machines, or S3 buckets, Clouder makes multi-cloud operations feel seamless and unified. 💡 Designed for DevOps teams, Clouder brings powerful collaboration and cost-optimization features: - Create and monitor Kubernetes clusters - Manage Helm deployments with ease - Schedule cluster scaling to optimize costs - Share clusters with secure, controlled access - Backup and restore for reliable disaster recovery - Supports alpha Kubernetes features like Container Checkpointing and Restore (CRIU) ☁️ Currently supports Azure, AWS, and OVHcloud—with more cloud providers coming in future releases. 👉 Dive in and learn more: https://clouder.sh

This example highlights the power of Agent Runtimes: a single agent can support multiple output formats seamlessly. From plain text and Markdown to structured JSON and UI-ready payloads, responses can adapt dynamically based on the client and protocol. ➡️ Build once, deploy everywhere. #AI #Agents #DeveloperTools

🛡️ AgentToolApprovalsExample: human-in-the-loop, in 4 lines of YAML. id: demo-full tools: - runtime-echo:0.0.1 # auto - runtime-sensitive-echo:0.0.1 # manual approval One Agentspec, two tools — runtime-echo ships, runtime-sensitive-echo waits for your 👍. Approve in the chat → dropdown updates live. Same agent, real guardrails. 🚀 #AIAgents #Datalayer

Should your AI agent need approval before running a skill—even for something as simple as telling a joke? What do you think? Personally, I believe it should be configurable 🙂 #AIAgents #Skills

Jupyter MCP Server 1.0.2 is out! 🎉 Now supports the default Jupyter stack—no more pinning older collaboration versions. Use the version you want. 👉 https://lnkd.in/eJx6E3RE

🤖 🚀 Agent Runtimes by Examples - What does it really take to build robust, production-grade agent systems? We’ve been exploring this question through a collection of concrete, hands-on examples—each one focused on a specific concern in modern agent runtimes. On the main page, you’ll find an example gallery (cards) that break things down into practical building blocks: • UX patterns (aka GenUI) with protocols like A2UI and AG-UI • Interactive or triggerd workflows • Agent Identity and Controls with guardrails, monitoring, tool approvals • Programmatic tooling with Sandbox and Codemode for MCP and Skills • Outputs and Notifications • Real-time collaboration with users, subagents, and multi-agent teams • Custom agents built from Agentspecs • ... Each of these concerns deserves more than a one-off solution—they need deep, composable, and pluggable implementations. That’s exactly what these examples aim to demonstrate. Explore the repo: https://lnkd.in/epJJ9gAQ Try it out. Build on it. Contribute back. Or simply star your favorite example ⭐ #AI #Agents #OSS #DeveloperTools #AgentSystems #OpenSource

Jupyter MCP Server 1.0.0 Reaches 1,000 GitHub Stars ⭐ Right after the official 1.0.0 release, the Jupyter MCP Server repository crossed the 1K stars milestone. A huge thank you to the community and contributors building the future of notebook-native AI workflows. Version 1.0.0 marks the first stable release of Jupyter MCP Server, with robust notebook lifecycle operations, multimodal context support, and production-ready deployment patterns. Reaching 1,000 stars immediately after that release reflects strong adoption across AI, data science, and developer tooling teams building with MCP and Jupyter. 🪐 🔧 https://lnkd.in/eJx6E3RE #Jupyter #MCP #Community #OpenSource

As LLM-powered applications move from prototypes to production, one challenge keeps surfacing: 👉 **We still lack clear visibility into token usage and cost.** Every prompt, tool call, and agent loop has a cost implication — yet in many systems, this remains opaque. The result? * Unexpected bills * Inefficient prompts and agent behaviors * Difficult trade-offs between quality and cost * Limited ability to optimize or even *understand* what’s happening 💡 **Observability is no longer optional — it’s foundational.** This is exactly where the open-source **agent runtimes** ecosystem from Datalayer comes in. The **agent-runtimes** package provides a unified way to build and run AI agents across models, frameworks, and protocols — with flexibility as a core principle ([PyPI][1]). But beyond orchestration, what's emerging is something even more important: 👉 **Runtime-level visibility into LLM usage** 🔍 Why runtime-level observability matters LLM cost is driven by *tokens over time*, not just single calls. Without runtime instrumentation, you miss: * Token accumulation across multi-step agents * Hidden loops or redundant tool calls * Latency vs cost trade-offs * Real production behavior vs lab assumptions In other words: you can’t optimize what you can’t see. ⚙️ How agent-runtimes helps Datalayer’s approach is powerful because it sits at the **runtime layer**, where everything happens: * 🧩 **Model-agnostic** → works with any LLM * 🔌 **Pluggable observability** → integrates with any OpenTelemetry-compatible backend * 📊 **Built-in React components** → reusable charts to visualize tokens, latency, and cost * 🔄 **Protocol abstraction** → one agent, multiple interfaces without code changes ([PyPI][1]) This means you can instrument once, and gain visibility everywhere. 🧪 What’s being built right now There’s active work happening to push this even further — especially around: * Fine-grained token tracking * Cost attribution per agent step * Standardized observability pipelines 👉 https://lnkd.in/eEyfUUiv 🚀 The bigger picture We’re entering a phase where: * LLMs are **infrastructure** * Agents are **systems** * And **observability is the control plane** Token and cost visibility will define how scalable, reliable, and efficient AI applications become. If you're building with LLMs today, ask yourself: 👉 *Do you actually know where your tokens (and money) are going?* [1]: https://lnkd.in/ewirS9Ma "agent-runtimes · PyPI"