Hacker Newsnew | past | comments | ask | show | jobs | submitlogin
 [flagged] Show HN: Open sourcing our ERP (Sold $500k contracts, 7k stars) (github.com/adenhq)
32 points by AdelAden 24 days ago | hide | past | favorite | 48 comments
We recently open-sourced Hive after using it internally to support real production workflows tied to contracts totaling over $500k.

Instead of manually wiring workflows or building brittle automations, Hive is designed to let developers define a goal in natural language and generate an initial agent that can execute real tasks.

Today, Hive supports goal-driven agent generation, multi-agent coordination, and production-oriented execution with observability and guardrails. We are actively building toward a system that can capture failure context, evolve agent logic, and continuously improve workflows over time - that self-improving loop is still under development.

Hive is intended for teams that want:

- Autonomous agents running real business workflows

- Multi-agent coordination

- A foundation that can evolve through execution data

We currently have nearly 100 contributors across engineering, tooling, docs, and integrations. A huge portion of the framework’s capabilities - from CI improvements to agent templates - came directly from community pull requests and issue discussions. We want to highlight and thank everyone who has contributed. Specifically out top 11 contributors @vakrahul @Samir-atra @VasuBansal7576 @Aarav-shukla07 @Amdev-5 @Hundao @Antiarin @AadiSharma49 @Emart29 @srinuk9570 @levxn



Congrats on the launch!

I've been dogfooding the framework heavily over the last month (~20+ PRs so far), mostly focusing on Developer Experience (DX) and Integrations.

What stood out to me was the flexibility of the Graph architecture compared to standard chains. I spent a lot of time this week building the Competitor SWOT Agent (using a MockLLM for offline testing) and smoothing out the onboarding flow-fixing uv setup issues on Linux, documenting undocumented runtime arguments, and adding new integration templates.

The shift from linear execution to the Router Pattern (having the LLM dynamically route tickets based on classification) is a huge unlock. Excited to keep building more complex agents on top of this!


Congrats on the launch! I'm Aaryann Chandola (Antiarin on github), been contributing to Hive for the past couple of weeks. Most of my work has been on the integration side. I built the Google Calendar integration, its an MCP tool suite that lets agents create, update, delete and search calendar events, including Meet links. The idea is you can have an agent that actually manages your schedule for you. I also put together the email integration for Gmail and Outlook along similar lines. One thing that bugged me early on was that the LLM agents had zero awareness of what day or time it was, so they'd just make up dates. I added runtime Datetime injection into the system prompts which was a small fix but made a noticeable difference. I've also been involved in some of the design discussions with the core team. Proposed centralising the hardcoded prompts scattered across the framework into a proper registry, wrote an RFC for closed-loop agent evolution (basically agents learning from their own runs), and contributed to the conversation around cron-style scheduled execution. Working on Codex integration as a coding agent right now.

Honestly what got me interested in Hive in the first place is the goal-driven architecture. Agents aren't just chains of LLM calls, they have explicit goals with success criteria that get evaluated. The graph-based execution with pause/resume and checkpointing makes it feel like a real runtime managing concurrent execution streams, not just a script runner.


This is a really cool project and I've enjoyed exploring it. I've worked on a couple of things within this repo. My preference was to use local LLMs as opposed to LLM API keys, as I'm working on developing local LLM usage to address the enterprise concerns of data privacy. Hive supports the usage of Ollama for local model inference, which I felt was a good starting point. During development, I found the Hive docs to be primarily focused on using Claude Code and OpenAI LLM inference, and development on Linux OS. I absolutely use Linux frequently, and also understand that there are many devs using Windows as well. Issue: Hive docs needed some fleshing out to produce clear guides, walkthroughs, and examples using the above framework. How to fix: I proposed a fully fleshed out guide using Ollama models, and CLI, along with a breakdown for both Linux and Windows users. Though, WSL works, again, I wanted to appeal to less technical users that may have an interest in Hive, and suggested a less technical approach for simple PowerShell or Linux CLI instructions. Why does it matter?: There are several reasons this is important, but primarily it has to do with creating a platform that not only highly technical people can use, but also beginner or intermediate users as well. This not only broadens the audience, but also demonstrates professionalism.

I've really enjoyed using the Hive framework to build some local LLM inference projects (currently using Hive for a short term/long term memory agentic system to address context window limitations, attention deficit, and drift in long conversations.


We are closely looking at compatibility issues for Windows users and UX improvements for everyone. Thanks for your honest feedback!


What was the issue? While Hive provides a powerful backend for autonomous agents, execution was a "black box." Debugging complex agent workflows—like when a scraper hits a 403 and needs to rotate proxies—was painful through terminal logs. There was no easy way to visualize the decision-making process, track token usage, or monitor costs in real-time.

How did you fix it? I built the Web Dashboard (hive/web) using Next.js and Tailwind CSS to provide a dedicated observability layer that syncs directly with the local runtime.

Real-time Visualization: Created a live view of agent runs, showing every step, tool call, and state change as it happens. Decision Tracing: Implemented a timeline view that breaks down exactly why an agent made a decision (e.g., "Switching to residential proxy due to 403 error") and what options it discarded. Performance Metrics: Added effortless tracking for token consumption, latency, and cost per run. Why does it matter? Trust is the biggest barrier to adopting AI agents in production. By highlighting "Self-Healing" events and making the agent's "brain" visible, we move from "magic" to engineering. This dashboard gives developers the confidence to deploy agents and the insights needed to optimize them when they fail.


The shift from 'black box' logs to a visual timeline is a huge step toward production reliability. For the decision tracing specifically—how are you handling the data serialization between the local runtime and the Next.js dashboard to keep latency low? I am curious if we can eventually use those 'Self-Healing' event logs to automatically tune our agent guardrails


I've been contributing heavily to Hive/Aden recently to help bridge the gap between "research framework" and "production platform."

My recent PRs have focused on improving Developer Experience and safety:

- Goal Decomposition Preview: I noticed a lot of "blind generation" in agent frameworks. I implemented a CLI feature (hive preview) that performs a lightweight LLM pass to decompose a goal into a directed graph structure (nodes & flow logic). It explicitly flags risks (e.g., ambiguous success criteria) and provides cost/complexity estimates before you generate a single line of scaffold code.

- Simulation Mode: To tighten the dev loop, I added a simulation harness that allows for dry-running agent logic against mocked inputs. This lets you test decision trees and retry mechanisms without burning real API credits or triggering side effects (like actually sending an SMS or writing to a DB).

- Enterprise Integrations: I’ve been fleshing out the MCP (Model Context Protocol) layer to support actual business workflows, including Microsoft SQL Server, Twilio (SMS/WhatsApp), Google Maps, n8n, and Zendesk.

- Persistent Memory: Just shipped integration with Memori to solve the statelessness problem, giving agents long-term context retention across sessions.

Happy to answer any questions on the implementation details.


Hi, I'm Shubhra, an AI Product Manager, I'll briefly say what I have been contributing at Hive using clear points-

1. What was the issue? Hive is positioned as a production-grade, goal-driven agent framework, but the first-time experience and agent interaction patterns are developer-centric and clarification-first. This creates friction before value: agents delay execution with conversational framing, and there is no single reference agent that demonstrates end-to-end business execution from a plain-English goal.

2. How did I fix it / what idea did I propose? I proposed a Sample Agent: Autonomous Business Process Executor that acts as a canonical, execution-first reference agent. The agent: Executes real, multi-step business workflows from a single goal Defaults to immediate execution instead of clarification-first UX Uses human-in-the-loop only at decision boundaries Validates outcomes via the eval system Produces business-readable summaries, not just logs This surfaces how Hive’s existing architecture (goal - graph - execution - eval - adaptiveness) works in a real production context.

3. Why does it matter? This closes the gap between Hive’s technical power and its product clarity. It: Reduces time-to-value for first-time users Makes Hive legible to founders, ops teams, and PMs—not just engineers Demonstrates real business value instead of abstract capability Aligns agent behavior with Hive’s execution-first, production-grade positioning

I liked the Hive Vision and approach, and I'm happy to answer any questions or add my inputs on the above things discussed or where ever required. Thank You!


Congrats on the launch. I built the Interactive TUI (Terminal User Interface) for Hive and want to clearly share the value it adds.

► What was the issue?

Hive agents were observable only through raw logs. That limited visibility into agent state, graph execution, and live interaction. Debugging required scrolling text and guessing progress while the agent ran.

► How did I fix it? I designed and implemented a full Interactive TUI dashboard in (Closed PR #2652).

The interface: A three pane terminal view that shows real time logs, a live execution graph, and an interactive ChatREPL in one screen.

The engineering: Thread safe event handling keeps the interface responsive during heavy agent workloads. Lazy widget loading reduces memory and startup cost.

Developer workflow: The goal was to streamline the "Run → Debug → Iterate" loop. Instead of reading logs after a failure, the TUI shows agent logic and tool calls in real time. The integrated REPL lets you test responses and adjust inputs in the same view where you monitor execution and performance.

► Why does it matter?

This changes Hive from a background process into a first class CLI tool. You get continuous visibility, faster debugging, and direct control during execution. It removes tool switching and improves daily productivity for engineers running agents locally or in production. Big thanks to the Aden team for testing, feedback, and support during review, which helped get this merged into core and shipped live.

Happy to explain the layout design or real time event handling if anyone wants deeper details.


That TUI was clean, very much appreciated!


Congrats on the HN launch

As a student contributor, I’ve been diving deeper into Hive core and exploring how its outcome-driven agent architecture fits together. Recently, I worked on hardening the quickstart.ps1 onboarding script to improve reliability on PowerShell mainly around path handling and some tricky NativeCommandError edge cases to ensure smoother setup outside ideal dev environments.

It’s been interesting working on the infrastructure side of a framework that dynamically generates and evolves multi-agent systems. Making the onboarding and execution layers stable is just as important as the higher-level agent logic.

I’ve also been experimenting with a lightweight TTL-based dictionary cache to reduce redundant operations in certain workflows. Still iterating on the idea, but it’s been a useful exercise in thinking through state management and consistency trade-offs in evolving agent systems.

Looking forward to continuing to contribute and explore Hive further. Building systems that can evolve and stay stable under real constraints is a fascinating challenge.


I architected an autonomous issue triage agent designed to filter noise and surface critical signals for open-source projects. Leveraging vector memory for duplicate detection and a custom "Novelty Scoring" algorithm, the agent intelligently distinguishes between redundant reports and genuinely new issues. It then compiles these insights into high-value, multi-channel digests (Email & Slack), ensuring maintainers focus only on what truly requires their attention.

Thought this can help all open source communities focus on real issues aligned to your goal and look out for enhancements and bugs of what severity it adds up to your existing code base. The plus point is that this can also be exposed as a github app bot which can be spun on your preferred duration (say 24hrs once) for the previous day's issue. It is compared with the entire history of other issues utilizing vectordb capabilities and helping you out with best ranked issues filtered and dropped in your inbox be it Email or any mode of communication.


I’ve been contributing to Hive and opened Issue #3763 around production readiness specifically missing reliability controls (retry, recovery, persistence) and cost transparency (token and workflow-level visibility).

I proposed structured retry policies, crash-safe state persistence, and cost observability via CLI/TUI. Based on maintainer feedback, I broke this down into focused sub-issues under #3763 to make implementation incremental and aligned with Hive’s architecture. I also submitted PR #4398 from my fork to improve documentation around production hardening and cost visibility.

This matters because production agent workflows need reliability and predictable cost behavior otherwise deployment confidence and adoption suffer.

I also contributed to Issue #4131 by proposing a “Post-Quickstart Evaluation Walkthrough” to help developers validate agent behavior immediately after setup and improve onboarding clarity.

Hive’s event-loop architecture is solid these contributions focus on helping bridge the gap from experimentation → production deployment.


I’ve been contributing at Aden (Amdev-5 on GitHub), where my focus has been on closing the 'actionability' gap by building out Hive’s integration ecosystem. To make the framework truly plug-and-play for business environments, I’ve focused on merging high-utility connectors like X (Twitter), Cal.com, Apollo.io, serp api, while currently refining a Google Maps PR to give agents better geospatial awareness. Beyond the tools themselves, I’ve been working anround infrastructure and architecting the SDR and Blog Writer sample agents. These weren't just meant as demos, but as blueprints for how multi-turn coordination can replace brittle, hard-coded automations in a real-world workflow. It’s been a blast so far and I’m happy to dive into any questions regarding the integration layer or our approach to multi-agent task execution.


Congrats on the launch — appreciate seeing open-source tools tackling this problem space.Hive is an Interesting project.I didn’t contribute code yet, but I did raise issues while exploring Hive. Issue: Some parts of the workflow and edge cases weren’t immediately clear from a first-time user perspective. Action: I opened issues highlighting usability gaps and questions around expected behaviour. Why it matters: Early feedback like this helps make the system easier to adopt and reduces friction for new users coming in cold. Curious to see how others here think about balancing power vs. usability in tools like this. For the authors: how are you thinking about handling edge cases or failures in real-world usage, especially when inputs are noisy or incomplete?


Hi everyone,

What was the issue? While exploring Hive for real-world finance use cases, I noticed there wasn’t a clear, reusable structure for implementing credit-risk logic inside agents. This made experimentation harder and limited how easily risk-related workflows could scale across agents. How did I fix it? I contributed by working on a credit-risk–focused agent/module, improving the structure, documentation, and alignment with the existing agent pipeline. The goal was to make the logic more modular and easier to extend as new agents and use cases are added. Why does it matter? Credit risk is a core problem in many real-world applications (fintech, lending, B2B workflows). Making this logic modular and transparent helps Hive support more serious production use cases, while keeping the system understandable and contributor-friendly.


Interesting application - how'd you like to implement the credit-risk logics? Do you want to write SQL expressions, mathematical models via Python, or some other way? By design, the framework should containerize these logics. But it'd better learn more.


Also interested in learning about you did this please


"Huge congrats on the launch! I recently had the opportunity to contribute to Hive by identifying and resolving a critical issue. It was a fantastic experience working with the codebase and the community." The issue was: Make success-criterion evaluation assumptions explicit in Outcome Aggregator. I fixed it by: Previously, all success criteria were implicitly treated as success-rate based, which could lead to misleading progress and met values for unsupported or future criterion types. This change ensures that only success rate criteria are evaluated, while others return a neutral, un-met status until proper evaluators are implemented. This improves clarity, correctness, and observability of the evaluation system without introducing breaking changes.


Congrats to the team on the launch

I’ve been contributing to Hive over the past couple of weeks, mostly around agent design patterns, integrations, and production-readiness.

What was the issue? Hive has powerful agent primitives, but early on there were few concrete reference patterns showing how to apply them to real-world, multi-step workflows.

How did I address it? I contributed by proposing and designing reference agent pipelines (e.g. multi-agent content research workflows) and scoped integrations focused on production use cases like security automation, scheduling, and external systems.

Why does it matter? Clear reference agents and narrowly scoped integrations make it much easier for teams to move from experimentation to real business workflows, which is where agent frameworks tend to break down.

Happy to answer questions or dive deeper into any of the designs.


Congrats on open-sourcing — the direction toward reliable agents really resonates.

One thing that stood out while contributing is how critical durability becomes once agents move from demos to long-running production workflows. Mutation loops, retries, or multi-step plans can be token-heavy and fragile if a process crashes midway.

I recently worked on adding optional crash-safe runtime state persistence (atomic temp+replace logic with restore on restart) so agents can resume from the last completed step instead of starting over. It’s fully opt-in, but feels like an important primitive as you build toward self-improving systems.

Excited to see where Hive goes — happy to help more on reliability and production hardening.


I contributed by identifying and reproducing an onboarding blocker where Hive examples could not be executed from a clean clone.

Issue: Running example scripts failed due to unresolved internal imports, since the repository was not installable as a package and no supported execution path was documented (issue #3207).

What I did: I reproduced the failure on a clean environment, documented clear reproduction steps, and provided a minimal fix so examples could run out of the box.

Why it matters: First-time users should be able to clone a repo and run an example immediately. Fixing this reduces onboarding friction and makes Hive easier to evaluate and contribute to.


Thanks for your contribution, much appreciated


Congrats on the launch! My contribution focus was on hardening the MCP (Model Context Protocol) infrastructure.

The Issue: JSON-RPC is fragile when mixed with standard logging. A single rogue print() to stdout corrupts the protocol payload, causing tools to fail unpredictably or agents to crash silently.

The Fix & Impact: Enforcing a strict stderr logging standard. This effectively separates "human debug info" from "machine protocol data." This is critical for moving agentic workflows from experimental demos to production-ready systems, ensuring stability even when integrated tools are noisy or throwing errors.


I contributed to the documentation by adding a comprehensive Goal Creation Guide. While the existing docs covered the node-and-edge architecture, there was a significant gap in explaining how to define Goals, Success Criteria, and Constraints — the core components of Outcome-Driven Development that actually drive an agent's learning loop. My guide bridges the gap between conceptual theory and practical implementation, giving developers a structured way to define what "success" looks like and how their agents should evolve over time.


It seems like everyone commenting here is already part of the hivemind. So maybe someone can answer an important question that I'm not getting at all from the docs: what does this actually do?


I developed a comprehensive Slack MCP tool suite that transforms Slack from a simple chat interface into a fully operational control plane for AI agents. It was tested end to end with other tool capabilities like CRM, where all executions can happen from slack itself, all you have to do is call this slack bot which is connected via webhooks hence anything you name it, it will use available tools to help you out with actions reducing multiple touch points. (I am @levxn on github, feel free to connect)


Thanks for you contribution so far! Yea, I saw that and I'm testing it today.


Coming in as a relatively new full-stack developer, I found a few areas where the codebase and flows were hard to follow at first.

I focused on improving things I personally struggled with — small refactors, clearer UI behavior, and incremental fixes that made the system easier to reason about while working on features.

If Hive is approachable for newer developers, it’s easier to grow a healthy community. Improving clarity and polish helps more people contribute with confidence.


100% usability right now is not optimal. I'm releasing a new version of the documentation and installation process today. Sync and pull tomorrow, it should be a lot easier.


Thank you for bringing this up to our attention. Delivering the first successes to our community members is our top priority right now. Stay tuned!


I’ve been contributing on the integrations side — recently added a native HubSpot CRM integration with OAuth2 support, credential handling, and full test coverage . The goal was to make it easier for Hive agents to interact with real-world sales and customer workflows in production.

Excited to be contributing more and learning from the Hive community

Thanks very much Vincent , Richard, bryan and again thank you to everyone who contributed !!


I really appreciate your efforts!There're so many valuable use cases that people can deliver via your CRM integration (e.g. leads automation, qualification, scoring, engagement, reporting, etc) It'd be great to test your HubSpot integration and see if these use cases can be brought to life.


Congrats on the launch! I’ve contributed CI/workflow improvements and tooling inventory updates (including keeping MCP tools docs in sync and adding a small inventory test). Excited to keep helping the project move faster. If helpful, I’d love to know if there’s a preferred roadmap for CI hardening or tooling expansion.


Contributed the BigQuery integration for querying data warehouses. Currently working on credential audit logging and runtime validation fixes.

The architecture here is solid - proper goal definitions with success criteria, not just LLM calls chained together. Congrats on the open-source launch.


Been hanging out in the Hive Discord for a bit—cool to see this go open-source after real production usage. The community has been very active and welcoming, especially around PR reviews and discussions. Congrats to the team and contributors.


I have contributed with production-ready changes as introducing Open Telemetry-compliant logging for the agents and JSON logging for general logging for production and human-readable general logging for developers.


Thank you. The OTel compatibility was neat for devops people.


I contributed a small validation around decision invariants in the runtime. Curious how you’re thinking about extending decision evaluation hooks and governance for production use?”


Here's the full story behind this project:

I grew up helping my dad run his factory so I'm very familiar with ERP systems for manufacturing. A few years ago, when I decided to build a startup and I indentified the biggest problems with ERP is the fact they all just serve as data integration and system of records now - there're not enough processes automation. Therefore, I thought it'd be very meaningful to leverage AI to automate business processes such as PO, Price Requisition, and invoices, etc.

3 years in, I realized that every customer in our space (construction and contracting) want process automation, however, AI is simply not good enough - it's too slow, unpredictable, inconsistent, and overall hard to count on. For example, automating a quote by asking AI to insert dynamic variables from a relational database is hit or miss. Asking voice AI to provide training does not capture full breadth of the offline activities. Asking AI to fill out a work order creates a ton of errors.

Later, we decided that though LLM and the foundation models were progressing fast, the dev tools were lacking way behind, particular behind all the hypes and promises these AI applications claimed. The agents are not reliable, consistent, intelligent, evolving, and chances are the market would demand more apps to keep the party going.

Therefore, we went full open-source. The mission we have in mind is really to "generate reliable agents that can run business processes autonomously". We see all this hype about general computer use (GCUs) and can't help but making an opposing argument - that the AI agents need guardrails, more defined paths, and most importantly consistent results just like a human would need

- Proactive Reasoning (anticipating future needs or consequences)

- Memory & Experience (events affecting himself/herself)

- Judgment (based on experience)

- Tools & Skills (capabilities to execute)

- Reactive Adaptiveness (handling immediate roadblocks)

- Contextual Communication (articulating intent and collaborating with others)

- Character & Traits (consistent behavioral biases: Risk profile, Integrity, Persistence)

The project seems to have gained a bit of a traction so far and I hope that you can fork it and tell the community what's missing and what we should be working on. I deeply thank you because the it's truly painful to build and deploy these one-off agents that don't get utilized. (https://github.com/adenhq/hive).


Amazing bro!!


Curious how you’re thinking about failure capture and agent evolution, feels like the hardest unsolved part.


That's indeed very hard - we're building runtime captures and they are fed to the coding agent (claude code, cursor, etc) to update the agents' codes. However, the runtime data needs to be structured in a certain way so the coding agents won't get confused. We're testing this a lot right now.


Tryout the interactive debugger to see failures captured in realtime!


I'll share a more detailed story behind this shortly.I'm one of the main contributors.


Holy moly AI written comments, Batman!


Super excited to see Hive on HN! I recently started contributing, focusing specifically on agent stability and tool hardening. The Issue: Agents are fragile. I found that tools like grep or view_file could easily crash an agent if it encountered a massive file or binary data. The Fix: I'm working on adding safety caps, pagination, and stricter input validation (just sent a PR for web_search!) to the core toolset. The Impact: This ensures agents don't accidentally "suicide" when exploring large codebases, making them reliable enough for actual work, not just demos.


Nice bro




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: