#software-engineering
Every summary, chronological. Filter by category, tag, or source from the rail.
Automating Python Dependency Resolution with Hybrid Replay-Repair
The paper introduces a hybrid pipeline that combines execution replay and automated repair to resolve complex Python dependency conflicts, significantly reducing manual intervention in environment setup.
Identifying Silent Failures in AI Agent-Tool Interactions
AI agents often suffer from 'silent failures' where tool invocations appear successful but return incomplete or incorrect data, silently propagating errors downstream into final outputs.
AI Agents as Catalysts for Ecosystem Modernization
AI agents are less important than the systemic improvements they force: cleaner data, standardized APIs, interoperability, and a shift toward outcome-based problem solving.
IBM TechnologyMitigating LLM Tool Hallucination via Closed-World Resolution
To prevent LLM agents from hallucinating non-existent tools, implement a closed-world resolution framework that strictly validates tool calls against a predefined, verifiable schema before execution.
MAGS: Ensuring AI Agent Safety via Multi-Agent Auto-formalization
MAGS introduces a multi-agent framework that uses auto-formalization to translate natural language agent outputs into verifiable code, ensuring safety and correctness before execution.
Moving Beyond LLMs: Jev and the Rise of Calibrated Decision Models
Jev is a new transformer-based model that replaces text generation with calibrated probability outputs, offering a faster, cheaper, and hallucination-free alternative for software automation tasks.
Modernizing Legacy Systems with AI-Assisted Migration
AI accelerates legacy system modernization by automating code discovery, documentation, and translation, allowing teams to preserve critical business logic while reducing technical debt and security risks.
IBM TechnologyBuilding Production-Ready AI Agents with Eve
Vercel's Chief of Software, Andrew Qu, explains how moving from complex agent chains to simple, file-system-based architectures doubled their agent performance and led to the creation of the Eve framework.
AI EngineerMastering Agent Harnesses: The Stack Behind Autonomous Coding
An agent harness is the essential infrastructure wrapping an LLM that provides the tools, memory, and guardrails necessary to transform raw model capabilities into reliable, autonomous software engineering workflows.
Agentic Engineering in Brownfield Codebases
Agents make code changes cheaper, but they don't replace the need for rigorous testing, clear system boundaries, and human-led verification in legacy environments.
Decoupling Readiness from Release for Agentic LLM Scheduling
The paper proposes a scheduling architecture for agentic LLM workflows that separates task readiness from execution release, specifically addressing tail-latency issues in multi-step AI pipelines.
Building Ambitious Software in the Age of AI
AI coding agents make code generation cheap, but they do not replace the need for rigorous architecture, manual code review, and human-led testing strategies in complex, long-term software projects.
AI EngineerPrinciples for Large-Scale AI Agent Coordination
Effective agent coordination requires isolated workspaces, specialized agent roles, and intelligent handoffs to manage complex tasks across parallel environments.
Building Reliable AI Systems with Graph Engineering
Move from monolithic prompts to graph-based architectures to eliminate hallucinations, reduce LLM costs, and improve reliability by separating deterministic logic from reasoning.
Google Cloud TechScaling AI Agents with Contextual Playbooks at LinkedIn
LinkedIn scaled AI coding agents to over 1,300 tools and 600 playbooks by replacing direct tool exposure with a three-meta-tool search architecture and a self-improving, playbook-driven knowledge loop.
AI EngineerHow 1Password Boosted Engineering Productivity by 21% with Codex
By integrating AI across the entire software delivery lifecycle—from planning to production—1Password achieved a 21% productivity gain and reduced pull request cycle times by 11% while maintaining strict security standards.
Shift from Implementation to Decision Quality in the AI Era
AI has commoditized code generation, shifting the engineer's primary value from writing syntax to making high-level architectural decisions, enforcing system-level governance, and validating outcomes through automated testing.
IBM TechnologyThe Hydration Proxy Pattern for Stateless LLM Architectures
The Hydration Proxy pattern solves the state management bottleneck in LLM applications by decoupling conversational context from the API request, allowing for efficient, scalable, and stateless data injection.
Graph Engineering for Predictable AI Workflows
Graph engineering provides a structured, deterministic approach to building multi-agent systems by defining explicit nodes and edges, offering superior control and debuggability compared to agent swarms or simple loops.
Google Cloud TechThe Evolution of Code Review: From Syntax to Outcome Validation
AI is shifting code reviews from manual syntax and consensus checks toward evidence-based validation of business intent, requirements, and outcomes.
IBM TechnologyBuilding Reliable AI Agents in Production
Treating agents like 2015-era microservices, Navan’s architecture emphasizes single-agent loops with pluggable skills, trajectory-based testing, and pre/post-tool call guardrails to manage non-deterministic behavior.
AI EngineerGoverning AI Skills: Scaling Agentic Workflows
AI-native organizations must treat 'skills' as first-class, governed assets—similar to microservices—to avoid technical debt, ensure deterministic outcomes, and maintain security at scale.
AI EngineerFormal Verification for AI-Generated Code with Lean4
As AI agents generate code at scale, traditional testing and human review fail to guarantee correctness. Formal verification using Lean4 allows developers to define specifications that machines prove mathematically, ensuring code is correct for every possible input.
Scaling AI Agents Safely: A Roadmap for Engineering Teams
Adopt AI agents by prioritizing verification over prompting, treating skeptic feedback as a safety roadmap, and maintaining human-centric communication standards to avoid 'slop'.
From AI-Assisted to AI-Native: Frontier Development Habits
Productivity gains from AI aren't about the tools, but about shifting from 'vibe coding' (babysitting) to 'frontier development' (feeding agents), which requires intentional changes to team habits and codebase hygiene.
Building uReview: Scaling AI Code Review at Uber
Uber built uReview, a multi-agent code review engine, to solve the bottleneck of increasing PR review times. By focusing on observability, team-specific customizations, and feedback-driven tuning, they achieved a 60% cost reduction and a 67% addressal rate for AI-generated comments.
AgentRoom: Enabling Concurrent Multi-Agent Coding via CRDTs
AgentRoom introduces a shared, CRDT-backed workspace that allows multiple AI agents to collaborate on code concurrently, solving consistency and conflict issues in multi-agent software engineering.
AI Agents: Why the Harness Matters More Than the Model
AI system performance is driven by the 'agentic harness'—the tools, memory, and loops surrounding the model—rather than just the model itself. Distinguishing between the 'brain' (model) and the 'jar' (harness) is essential for building effective AI agents.
IBM TechnologyTerminal Agents: The State of AI in Command-Line Environments
This survey provides a comprehensive overview of AI agents designed to operate within terminal environments, detailing the architectures, evaluation methodologies, and challenges of automating command-line tasks.
Spec-Driven Agentic Development (SDAD) for AI-Native SDLC
SDAD shifts software development from code-centric to specification-centric workflows, using AI agents to enforce rigorous, machine-readable requirements that drive the entire lifecycle from design to deployment.
Showing 30 of 243