Copyright thenewstack
Software bugs are huge pests, wasting developers’ time and slowing down release cycles. Boris Paskalev, co-founder and CEO of LogicStar AI, has been chasing them for years. In 2017, he founded DeepCode and then led it to a 2020 acquisition by Snyk, staying with the team for about three years to support the platform’s growth. Seven years later, he joined co-founders Mark Niklas Müller and Martin Vechev to form LogicStar, for what looks like the natural continuation of its predecessor. Where DeepCode aimed to “identify bugs before they happen,” LogicStar goes a step further to “not only identify the issues — because there are many tools that can do that,” notes Paskalev, “but … autonomously investigate, reproduce, fix and validate that the fixes are correct before a human engineer even gets involved.” Behind-The-Scenes Debugging Starts With the Application-Specific LogicStar is shooting high: Ninety percent precision in accuracy of bugs fixed (i.e., what Paskalev says humans can achieve). But if the platform does its job, then humans shouldn’t have to get involved at all. As he describes it: “From a customer perspective, nothing happens. You just come, [and the] pull request is ready.” That’s because LogicStar is busy at work behind the scenes, monitoring bug backlogs (e.g., alerting systems, QA, locks, etc.) to correlate signals, analyze code and deliver fully validated fixes. Suppose, for instance, an e-commerce company receives complaints that tax isn’t being calculated at checkout. With its investigation agent, LogicStar can identify and confirm the problem. Meanwhile, other agents get to work to reproduce the bug. “They’re actually trying to create a small piece of code or script that says, ‘If you execute that, this particular bug will trigger in the code base,’” Paskalev explains. That confirms the bug is real and reproducible — not a one-off fluke. From there, LogicStar determines the best fix by running multiple candidate fixes through various models and agents. The foundation for this identity-verify-fix setup begins at onboarding. “When we first onboard the project, we do a very deep static, dynamic analysis of the project,” says Paskalev. “We break it up into pieces so we have our internal representation [of] … all the important modules of the application” (e.g., what the modules do, how they’re connected and how they communicate with each other and external applications). It’s this rich context that enables LogicStar to identify and fix software bugs with such accuracy. “We can tell the LLMs [large language models], ‘The problem is exactly here. This is the sequence of events that led to that specific issue — now try to fix it,’” says Paskalev. That context also makes way for cheaper model queries. Because LogicStar can precisely identify how and where a bug occurs, it can query smaller, cheaper and faster LLMs, not only reducing operating costs but increasing the chance it will come up with the right fix. It can even run multiple models simultaneously to compare proposed fixes. Less Time Fixing Bugs, More Time Building — No Babysitting Required If LogicStar can efficiently take over bug fixing, as Paskalev proclaims, developers can look forward to several downstream benefits. Most obviously, automated bug fixing means more time back in the day, taking tasks like triaging, investigating and reproducing off developers’ loaded plates. “Each hour spent on fixing bugs … is one hour [of] opportunity lost on working on new features — and you usually have a 10x multiplier in the ROI or value created for building new features that customers will pay for,” adds Paskalev. He also points out that LogicStar does away with false positives, a thorn he claims other tools actually create: “With a lot of bug-finding tools, there’s a large amount of false positive[s] … You have to identify, ‘Do I really want to fix that? Is it really a problem? Or is it just a false positive?’” But because LogicStar reproduces and validates every issue before passing it to engineers, it dramatically cuts normal bug-finding and -fixing workflows, including time wasted on false positives. In fact, Paskalev says LogicStar can reduce bug life cycles by 95%, which he attributes to the platform’s fully autonomous workflow. This is a notable distinction from many other tools that still ask developers to get their hands dirty. “What happens in the co-development world … you’re constantly asking the required human in the loop to tell the LLM, ‘Is that correct?’” Paskalev explains. “While in our case, we’re doing a human hand-off.” Again, it’s context that seems to be LogicStar’s secret weapon. Thanks to its onboarding-stage analysis, the platform can build a working understanding of the application to target bugs with keen precision. Another key feature Paskalev points to is its sandbox execution environment. Before a fix even reaches developers, LogicStar has already tested and validated multiple different fixes in isolation, ensuring that only proven fixes make it to the dev team. The platform can also generate new tests (for both the fix itself and related parts of the application) to prevent unintended breakage. Similarly, it can identify and run relevant existing tests to catch regressions before they happen. “Most tools out there, they do require a human in the loop, which means a human has to validate if the problem [got] solved or not; a human has to point out which tests have to be run; or a human has to provide their own execution environment,” he says. But with its sandbox environment, validation process and context-rich analysis, it seems LogicStar may have developed the secret sauce to near-human-free debugging. What remains to be seen is whether developers are ready to hand over the reins. But Are Developers Ready To Go Truly Hands-Free? The recent outpour of supposedly fully autonomous AI solutions is starting to overwhelm the market — and underwhelm users who are souring on all the wonder products that overpromise and underdeliver. “Are people skeptical? Yes,” says Paskalev. “They have been burned by [the] extremely large amount of tools that are, as we call them, thin wrappers around large language models, [where] pretty much, you put a nice user interface, post a model, and hope that you’re getting something useful.” He’s candid in his disdain for these cheap tools that “just waste time” — and he’s not alone. When it comes to AI in coding, enthusiasm is waning, and distrust, waxing. In Stack Overflow’s 2025 Developer Survey, positive sentiment for AI tools dropped from 70%+ in 2023 and 2024 to just 60%. The report also reveals that more developers actively distrust (46%) than trust (33%) the accuracy of AI tools. Shooting for Production-Ready Precision Despite reservations, developers may be more prepared to trust AI if it promises to take over bug finding and fixing — what Paskalev calls “the most hated part that developer[s] have to do in their daily work.” He claims he’s seen the mood shift firsthand when teams commit their first pull requests with LogicStar: “We definitely see this wow effect … More than 95% of the time, it’s [the bug-fix] just purely automated and gone.” Apparently, LogicStar is even creating a wow effect internally. “Just a year ago, we were thinking, ‘Can we achieve 5% [bug coverage]?’ Then … we’re seeing 10–20%. And now, in the past couple of weeks, we’ve seen 40%,” Paskalev says. He credits this impressive progress to better agents, deeper analysis and improved tools. And because LogicStar is model agnostic, he predicts even more gains as models continue to improve. Improvements, he says, will largely come from increasing model specialization, as large, generalized LLMs make way for smaller, more focused models that are trained for specific tasks — and noticeably easier, faster and cheaper to run. Eventually, the goal is to reach a point where LogicStar doesn’t just hand off a ready fix to humans; it goes so far as pushing fixes directly to production. It’s a developer’s wish LogicStar is determined to shoot for.
