DEV Community: pablo padlo

Choosing the Right AI Agent Framework for Your Workflow

pablo padlo — Sun, 06 Sep 2026 10:25:35 +0000

Choosing the Right AI Agent Framework for Your Workflow

With 85% of organizations integrating AI agents into workflows, selecting the right AI agent framework is critical. The market has shifted from passive tools to autonomous systems, making the choice of architecture essential for scaling beyond simple prototypes.

Core Architectures Defining Modern AI Agent Frameworks

Defining AI Agent Frameworks and RAG-Centric Architectures

An AI agent framework binds large language models, external tools, and prompt strategies into systems that execute autonomous tasks instead of generating static chat responses. These architectures act as the reasoning engine for flexible action. Market data confirms this transition from experimentation to production, with projections reaching $50.31 billion by 2030 at a 45.8% CAGR.

Deploying Stateful Workflows with LangGraph and CrewAI

Stateful workflows operate as finite state machines where graph nodes preserve context across multi-step logical loops. LangGraph models agents this way by offering explicit state management and human-in-the-loop checkpoints, although this architectural rigor creates a steep learning curve for new developers.

LangChain vs AutoGen: Selecting Frameworks for Multi-Agent Scale

Choosing between LangChain and AutoGen depends on whether the architecture requires modular chains or native conversation loops. LangChain provides a general-purpose foundation where developers construct linear sequences. AutoGen from Microsoft enables autonomous multi-agent collaboration through conversational patterns.

Feature	LangChain	AutoGen
Primary Pattern	Linear Chains	Conversational Loops
Multi-Agent	Via LangGraph	Native Core
Best Use Case	RAG Pipelines	Collaborative Tasks

A $60/Month VM Running an LLM Agent Now Does Autonomous Security Work

pablo padlo — Tue, 25 Aug 2026 12:05:17 +0000

A $60/Month VM Running an LLM Agent Now Does Autonomous Security Work

Ivan Novikov, CEO of Wallarm, posted a claim on X yesterday that pulled 2.5k impressions in its first hours: it has never been this easy to run cybersecurity autonomously. His setup is a dedicated virtual machine — about $60 per month — with an LLM agent on it that never pushes back on security work.

The refusal problem he's solving

Public coding assistants come with guardrails. Novikov's dig is aimed at Claude Code: in his experience it either refuses security-related tasks outright or silently switches you to an older, less capable model when the work gets sensitive. For a security engineer, a tool that negotiates is a tool that fails at the worst moment.

A dedicated VM removes the negotiation. The model inside has no policy layer to trip over, and nobody throttles it mid-scan.

The actual workflow

The setup is one prompt long. You tell the agent to install Sourcegraph for semantic code search or xerj.org for patch and impact analysis. From that point it runs unattended:

Patch hunting — the agent scans source code for incomplete patches: fixes that were reverted, partially applied, or quietly dropped in a later refactor
Runtime tracing — suspected issues get validated by observing execution, so the report isn't a pile of static-analysis false positives
Persistence — it keeps going for days, iterating over the codebase without a human driving each step

That last part is the actual shift. Security tooling has always been good at finding candidate bugs; the expensive part was a human verifying them. An agent that both hunts and validates compresses that loop.

The economics

$60 a month is less than an hour of a junior security analyst's time in most markets. The agent works around the clock and doesn't context-switch. Novikov's summary: "I feel like I woke up."

The obvious caveats

An agent with no pushback also has no brakes. It will happily scan code it has no permission to touch, and its findings still need human review before anyone acts on them. Autonomy changes who does the boring work — it doesn't remove accountability.

Source: Ivan Novikov on X

SuperQwen3.8-27b-abliterated: The New Open-Source AI Model

pablo padlo — Tue, 25 Aug 2026 06:33:50 +0000

SuperQwen3.8-27b-abliterated: The New Open-Source AI Model

SuperQwen3.8-27b-abliterated has just been released, and it’s already making waves in the AI community. This uncensored model features a 1M context window and is multimodal, making it a versatile tool for developers and researchers alike.

Key Features

Uncensored: Offers maximum flexibility for various applications.
Fixed Weights: Resolved with an agent swarm approach.
1M Context: Handles large context windows with ease.
Multimodal: Supports multiple data types for comprehensive analysis.

Why It Matters

SuperQwen3.8-27b-abliterated addresses common issues like overthinking and weight problems, ensuring smoother and more reliable performance. The team spent an extra week super-tuning the model, but the results are worth the wait.

Getting Started

To get started with SuperQwen3.8-27b-abliterated, head over to the official repository and start experimenting today. Whether you're working on NLP tasks or multimodal projects, this model has got you covered.

Conclusion

SuperQwen3.8-27b-abliterated is a powerful addition to the open-source AI landscape. Its uncensored nature and robust features make it a must-try for anyone in the field. Dive in and see what you can create!

Agent Framework Benchmarks: Why Architecture Beats Brand

pablo padlo — Tue, 25 Aug 2026 05:12:17 +0000

Agent Framework Benchmarks: Why Architecture Beats Brand

After 45 tests across 5 top frameworks (LangGraph, AutoGen, etc.), we found:

Quality spread: 0.56 points
Time differences: 22-47%
Token variance: Up to 18%

The framework choice matters less than its architectural fit.

Key Findings

Framework Type	Pros	Cons
Graph-based	Predictable costs	12-15% slower
Async	Flexible workflows	Debugging complexity
Sequential	Simple implementation	Poor error recovery

Current Market Trends

Consolidation from 50+ to 5-9 production-ready options
Standardization via Model Context Protocol
Shift from novelty to stability

Stop optimizing for hypothetical quality gains. Start matching frameworks to your infrastructure constraints.

Xiaomi AI Cube: a GB10-class competitor from China

pablo padlo — Tue, 25 Aug 2026 02:36:33 +0000

Xiaomi AI Cube: a GB10-class competitor from China

Xiaomi showed its AI Cube prototype — a compact local-AI box with three custom Xring chips (O3, O100, D100), 200 TOPS NPU, 1.22 TB/s memory bandwidth, up to 160 GB unified memory and 150 W sustained power. The claim: 120B models running fully locally.

Key specs

3 custom chips: Xring O3, O100, D100
200 TOPS NPU
1.22 TB/s AI memory bandwidth
Up to 160 GB unified memory
150 W sustained power
120B models locally

The notable part is that Xiaomi uses its own silicon instead of a rebadged reference design — the same playbook that made GB10-class devices popular, now with a Chinese supply chain.

Top AI Agent Evaluation Tools in 2026: MLflow Leads

pablo padlo — Mon, 24 Aug 2026 11:59:53 +0000

Top AI Agent Evaluation Tools in 2026: MLflow Leads

MLflow dominates with 30M+ monthly downloads, but DeepEval and Ragas are strong contenders.

Trace-Aware Scoring

Binary pass/fail scores on final outputs are no longer sufficient. Modern agents require systematic scoring of task performance by assessing intermediate steps like tool selection.

Multi-Turn Evaluation

Single-turn testing creates a blind spot for production agents because it fails to capture context carry-over or recovery from earlier mistakes.

Framework Comparison

Framework	Multi-Turn Support	CI/CD Integration	Open-source
MLflow	Yes	Yes	Yes
DeepEval	Yes	Yes	Yes
Ragas	Yes	Yes	Yes
Arize Phoenix	Limited	Yes	Partial
LangSmith	Yes	Yes	No

DeepEval and Ragas also confirm support for metrics, multi-turn evaluation, and CI/CD integration according to recent comparisons. However, Ragas lacks native conversation simulation capabilities.

DEEP Robotics DR02: The Industrial Humanoid Built for Real Weather

pablo padlo — Fri, 21 Aug 2026 14:37:04 +0000

DEEP Robotics DR02: The Industrial Humanoid Built for Real Weather

Most humanoid robot demos look impressive — until you notice the polished floor, the studio lights, and the operator standing just out of frame. The real test is not a stage in Shenzhen or a lab in Boston. It is a dusty warehouse at 45°C, a freezing loading dock at night, or a factory floor where a single failed seal means a six-figure repair.

That is the market DEEP Robotics is aiming at with the DR02.

What the spec sheet actually means

The DR02 is billed as an industrial humanoid robot designed for all-weather operation. Two numbers matter more than the rest:

IP66 protection — dust-tight and protected against powerful water jets. Not "splash resistant." Not "lab clean." IP66 means it can survive the kind of environment where forklifts kick up grit and pressure washers are part of the cleaning routine.
-20°C to +55°C operating range — cold storage, foundries, outdoor yards in summer, unheated logistics hubs in winter.

Those are not nice-to-haves for marketing decks. They are the difference between a demo unit and a machine that can be insured, scheduled, and maintained as production equipment.

Use cases that justify the hardware

DEEP Robotics calls out three primary jobs for the DR02:

Cargo transport — moving goods across short distances in environments where AGVs struggle with stairs, ramps, or unstructured layouts.
Emergency response — entering spaces where sending a person first is risky, but current wheeled robots cannot navigate.
Factory operations — repetitive material handling, tooling, and inspection in conditions that would degrade lesser hardware.

The design is human-like because the world is built for humans. Door handles, stair rails, pallet jacks, and control panels are all sized for a human body. A humanoid does not need the facility to be retrofitted.

Modularity as a maintenance strategy

One easily overlooked detail: the DR02 uses modular components. In industrial deployments, downtime is measured in thousands of dollars per hour. A sealed, monolithic robot that requires factory service for every joint replacement is a liability. Modularity means a technician can swap a limb, a sensor, or a drive unit on site.

Why this matters now

Humanoid robotics has passed the "can it walk?" phase. The next phase is "can it work?" Unitree, Figure, Agility, and now DEEP Robotics are all racing toward the same gate: a robot that can be deployed, fail predictably, be repaired quickly, and operate within existing safety and environmental standards.

Weatherproofing is a signal of that maturity. You do not design IP66 seals for a TikTok demo. You design them for a customer who will sue you if the machine dies on its first rainy night shift.

Video

// Detect dark theme var iframe = document.getElementById('tweet-2090807449502560535-451'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2090807449502560535&theme=dark" }

Bottom line

The DR02 is not the most famous humanoid robot on the internet. But the combination of IP66 sealing, wide temperature range, and modular serviceability points at a more useful class of machine: one that does not need a climate-controlled room to earn its keep.

In the next two years, the split in humanoid robotics will not be between "good at walking" and "bad at walking." It will be between robots that can survive a real work site and robots that cannot.

AI Coding Agents: Why Harness Architecture Beats Model Smarts

pablo padlo — Fri, 21 Aug 2026 12:05:53 +0000

AI Coding Agents: Why Harness Architecture Beats Model Smarts

OpenAI’s Codex now serves 5 million weekly users, but the competitive edge has moved from model quality to harness architecture—the systems wrapping AI models.

The Harness Difference

Modern agents combine:

Language models for reasoning
Control loops for execution
Tool access (terminals, APIs)

This turns autocomplete into autonomous coding. Example workflows:

Refactoring across 100+ files
Running test suites overnight
Migrating codebases automatically

Tradeoffs: Cloud vs. Local

Type	Pros	Cons
Cloud IDE	Easy setup	Latency, vendor lock-in
Local CLI	Full control	Steeper learning curve

Token Efficiency

Agent	Token Burn	Best For
Codex	Baseline	Most tasks
Claude Code	3-4x higher	Deep context needs

Why 11 Nines Beats 99.99% Uptime for Object Storage

pablo padlo — Wed, 19 Aug 2026 10:42:04 +0000

Why 11 Nines Beats 99.99% Uptime for Object Storage

99.999999999% durability means one object lost per 10,000 years. Availability — the 99.99% number everyone quotes — says nothing about whether your bits are still intact.

The two metrics sit on different axes. Availability measures whether you can reach the service; durability measures whether the data survives permanent erasure or silent corruption. Most storage tiers market the first while your archive quietly rots on the second.

The math behind eleven nines

Eleven nines is a statistical probability of loss so small it reads like a rounding error — until you multiply it by a billion objects. Going from nine nines to eleven nines is a 100x reduction in annual loss probability.

Metric	What it measures	Typical target
Availability	Access success rate	99.99%
Durability	Permanent erasure risk	99.999999999%
Integrity	Bit-level correctness	Active checksum verification

Passive vs active integrity checking

The real difference between storage classes is when corruption gets detected. Passive storage validates nothing until a read fails. Active integrity checking runs checksum comparisons on a scheduled cycle and repairs fragments before anyone asks for them.

Feature	Passive Validation	Active Integrity Checking
Trigger	On-read access	Scheduled interval
Detection Latency	High (until access)	Low (within cycle)
Risk Profile	Undetected loss	Immediate remediation

That latency gap is the whole game. S3 RRS-class services can serve corrupted data for months and you won't know until a restore attempt blows up in your face.

What replication does — and doesn't do

Geo-redundant replication handles hardware failure and site disasters by reconstructing from surviving copies. It does nothing about human error: an accidental rm -rf propagates across every replica instantly.

Risk Vector	Standard Protection	Immutability Control
Hardware Failure	Replication	Replication
Admin Error	None	Locking Policy
Malicious Actor	Access Logs	Retention Guard

Immutability (WORM-style object locks) is the layer that turns replication into an actual data-protection story. It has a cost: recovery from a genuine mistake means waiting out the retention window.

Tape vs cloud: the physical vector

Physical media fails differently — magnetic decay flips bits with no warning, and the transport chain adds human error. Iron Mountain-scale operations would still lose ~50 objects per year at a five-nines failure rate.

Risk Factor	Physical Tape	Cloud Object Storage
Degradation Detection	None until failure	Active checksum verification
Transit Security	High theft risk	Encrypted in-flight replication
Durability Guarantee	99.999999999%	99.999999999%
Redundancy Class	Single point of failure	Multi facility redundancy

Scale it up: 1 PB of objects

1 PB of data at typical file sizes is roughly a billion objects. On a reduced-redundancy tier, that "small" annual failure probability becomes ~120,000 lost objects per year. The gap between four nines and eleven nines is the difference between statistical permanence and slow, silent erosion.

The takeaway: audit your storage classes this week. If your primary backups or long-term archives sit on a tier with unknown durability guarantees, you're not saving money — you're deferring a restore-time surprise.

Originally published on storagenews.top.

IPv6 vs IPv4: Why Free 128-bit Addresses Beat the $26.81 IPv4 Tax

pablo padlo — Wed, 19 Aug 2026 05:12:19 +0000

IPv6 vs IPv4: Why Free 128-bit Addresses Beat the $26.81 IPv4 Tax

IPv6 already carries 35% of global internet traffic, and it costs nothing to provision. IPv4 leases keep getting more expensive. Here's the math and the migration mechanics.

The price curve is the argument

Legacy IPv4 addresses averaged $26.81 between January 2025 and February 2026 — up from a historical low of $5 in 2011. IPv6 blocks, by contrast, are routinely provisioned for free: a /48 block costs nothing because the 128-bit space holds roughly 340 undecillion addresses.

Metric	IPv4 Legacy	IPv6 Native
Avg. latency	Baseline	Lower
Packet loss	Higher variance	0.5%
Global share	Declining majority	35% (early 2026)

Why v6 packets are cheaper to forward

The fixed 40-octet IPv6 header removes per-hop work: no header checksum, no router-side fragmentation, options moved to extension headers. Routers skip integrity checks on every hop, and fragmentation happens at the source only.

Feature	IPv4 Header	IPv6 Fixed Header
Base size	Variable (20–60 bytes)	Fixed 40 octets
Checksum	Required	Absent
Fragmentation	Router and host	Host only
Options	In header	Extension headers

Three migration paths, one realistic answer

Dual-stack — run both stacks; Happy Eyeballs prefers v6 when both record types exist. This is the sane default.
Tunneling — wraps v6 in v4, but shrinks MTU and adds latency. A stopgap, not a strategy.
NAT64 — the translation mechanism for networks where the ISP supplies only one public-facing v6 address.

The shortcut rule for shortening v6 addresses

Remove leading zeros per hextet, then replace the longest run of zero hextets with :: — exactly once. Expand back to eight groups to verify. Non-canonical forms get rejected by validation tools.

Rule	Action	Example
Leading zeros	Remove preceding zeros	0042 → 42
Zero compression	Replace longest run with ::	2001:0:0:1::

What I'd actually do

Audit your cloud vendor for the free IPv6 blocks already sitting in your account, publish AAAA records, delegate ip6.arpa for reverse lookups, and let Happy Eyeballs do the steering. Migration costs engineering time; staying put costs a lease bill that compounds — CGNAT overhead, dual-stack maintenance, $26.81 per address.

первоисточник: wirez.top

This Robot Outruns You

pablo padlo — Tue, 18 Aug 2026 12:30:16 +0000

This Robot Outruns You

Unitree just published thirty seconds of footage that moves the physical-AI conversation. A humanoid clears two meters from a standing jump and tops out at 12.66 meters per second on the run — numbers no legged machine has posted before, and better than a lot of humans.

The numbers

2 meters — standing vertical jump, straight up from flat feet.
12.66 m/s — top speed, roughly 28 mph. Usain Bolt peaked around 12.42 m/s.
0.85 m — leg length, short by design for a low stance and fast cadence.

Why the timing matters

Unitree released the clip on Sunday — two days before its planned IPO. That isn't a coincidence. A company doesn't drop a record-breaking demo right before its listing by accident. It's a statement of value aimed at the same investors who've spent two years asking whether humanoids are real or vapor.

Beyond the flip videos

The humanoid space has spent a year trading viral clips — backflips, kung fu, dance routines. Impressive, but locomotion demos that don't translate to work. A standing two-meter jump and a 12.66 m/s sprint are different: they're a locomotion envelope, the kind of spec that shows up on a datasheet for a machine that has to actually move through the world.

The takeaway

Physical AI is moving from spectacle to spec sheets. When the question shifts from "can it dance" to "what's its jump height and top speed," the category is maturing — and the machines are getting faster than the people they're meant to work alongside.

Agent orchestration: code-based flow vs LLM planning

pablo padlo — Mon, 17 Aug 2026 09:51:54 +0000

Agent orchestration: code-based flow vs LLM planning

code-based control beats llm-driven planning when your workflow needs predictable speed, cost and performance. the choice is structural: hardcode the decision path, or let the model plan autonomously. hcltech's multi-agent setup cut case resolution time by 40% — that's the difference between deterministic flow and probabilistic guesswork.

the two camps

Feature	LLM Orchestration	Code Orchestration
Control Owner	Model (Runtime)	Developer (Pre-set)
Predictability	Low (Probabilistic)	High (Deterministic)
Best Use Case	Open-ended exploration	Fixed workflows

llm planning only wins on open-ended scenarios needing flexible tool use. code state machines eliminate the variability — if you need predictability, you need code guards. and no single prompt does both reliably.

agents as tools vs handoffs

Pattern	Control Ownership	Best Use Case
Agents as tools	Manager Agent	Bounded subtasks; unified output synthesis
Handoffs	Specialist Agent	Direct response requirements; focused prompts

rule of thumb: if the manager must narrate results, use tools. if the specialist must drive the dialogue, use handoffs. and you can combine them — triage agent hands off, the specialist then calls other agents as tools for narrow computations.

the human bottleneck

Risk Factor	Mitigation Strategy
Review Bottleneck	Limit active agents to 10-20 per function
Opaque Failures	Enforce deterministic code paths for critical steps
High Labor Cost	Optimize oversight workflows before adding agents

human review capacity, not agent count, binds production scaling. labor costs for supervision exceed compute expenses in human-in-the-loop setups. align agent count with actual review bandwidth before adding more.

reliability mechanics

Pattern	Mechanism	Constraint
Parallel Execution	asyncio.gather runs agents concurrently	Token budget multiplies by agent count
Evaluation Loop	while loop repeats until criteria met	Risk of infinite cycles without exit

parallel runs cut latency but burn tokens — cap the budget. evaluator loops force convergence but cost two extra model calls per failed pass. monitor rejection rates to tune evaluator strictness.

structured outputs fix routing

Failure Mode	Unstructured Output	Structured Output
Routing Logic	Substring matching fails on variations	Exact enum matching guarantees accuracy
Error Handling	Complex regex required	Native parsing exceptions
Context Usage	High token consumption for explanations	Minimal token overhead

force agents to emit json schemas instead of free text, parse the result in the app layer, and routing becomes code-verified instead of model-guessed. the cost: exhaustive category definitions upfront, schema validation failures to handle gracefully.

https://aiagentsnews.top/posts/agent-orchestration-code-based-flow-vs-llm-planning/