NMC3

Compute, Cloud & Consolidation

Comment

NMC3: Agent Orchestration for Everyone

An internal agent orchestration platform connecting teams, automating workflows, and making AI agents accessible to everyone, regardless of technical experience.

(Please press demo link)

Inspiration

Our inspiration for building NMC3 came from our team's personal experiences working internships in a variety of roles, from PM to BA to SWE. We all needed to work with agents in one form or another, but due to company restrictions and the hassle of building and connecting an agent, we ended up dealing with the tools we already had.

If we had access to a tool that had already gone through the difficulty of connecting and integrating with the tools our roles required, we would have been in a much better spot.

This led us to NMC3: a centralized platform where employees can build, use, and manage agents without having to worry about the complexity of setting them up or integrating them into existing workflows. Rather than replacing existing applications, we wanted to unite them under one agent orchestration framework.

What it does

NMC3 is more than just one product. It's three layers built on each other.

1. Core Agent API

The lowest level of the stack, and the most complex, is the NMC3 Core Agent API, where agents and agent workflows are built, run, and monitored. It serves as the foundation of the platform, handling execution, orchestration, permissions, and run history.

2. Agent Orchestration SDK

The second level is the NMC3 Agent Orchestration SDK, designed around the core API to make it easier for developers to create scripts and have agents run, create, or stop workflows.

This is where the power of NMC3 comes in, with automation capabilities and application integration. Building agents could never be simpler.

3. Agent Orchestration Website

Or could it?

The last and final part of the stack is the NMC3 Agent Orchestration Website, a streamlined interface to the underlying infrastructure that allows nontechnical users to harness the power of agents without writing code.

Users can create and configure agents, connect tools, manage threads, and monitor execution. Our broader goal is to preserve and share relevant context across agents and departments, reducing repetitive work and complicated handoffs.

NMC2 Capabilities and Our Implementation

During the NMC2 workshop, we explored the capabilities an internal agent platform would need. We used these requirements to guide our architecture and implementation.

Capability Our Implementation / Approach
Use Cases & Templates Internal capability requests, agent specifications, and reusable configuration templates.
Connectors & Tools MCP-based integrations, including GitHub and Google Drive, with an extensible tool registry.
Context Persistent threads, file attachments, and planned permission-scoped context sharing between agents.
Hardware Resources Resource requests and approvals, with future integration into compute allocation.
Evaluations Evaluation records and a planned automated framework for model comparisons, accuracy, and success rates.
Triggers Manual and API-based execution, with scheduled and event-driven workflows planned.
Model Selection Configurable models through the OpenCode execution backend.
Budgets Execution limits, token and cost monitoring, and separate budget approval records.
Guardrails Deny-by-default tool permissions, restricted delegation, and execution boundaries.
Security Employee authentication, role-based permissions, approval controls, and restricted data access.
Prompts Agent instructions, configurable definitions, and revision-based specifications.
Observability Execution graphs, run timelines, event histories, tool activity, and recorded outcomes.

Together, these capabilities create the foundation for a governed agent lifecycle, from initial configuration to execution and monitoring.

Example: Internal PR Review Agent

Imagine an NMC2 Hardware team needs an AI agent to review pull requests.

Rather than building a separate agent, they submit a request through NMC3. The Software/AI team clarifies the requirements, configures the necessary agents and tools, and submits the specification for approval.

The agent infrastructure can then execute and monitor the resulting workflow.

This is the kind of interdepartmental collaboration we want NMC3 to simplify, connecting NMC2's internal Hardware and Software divisions while supporting the company's broader GPUaaS operations.

How we built it

We designed NMC3 around a three-layer architecture separating agent execution, developer interfaces, and the website.

Backend and Agent Infrastructure

We built the backend primarily in Go, using PostgreSQL and Supabase for application data, agent definitions, authentication, and execution history.

We integrated OpenCode for model-backed agent execution while developing our own API for agent definitions, permissions, orchestration, and monitoring.

Our architecture supports primary agents delegating work to authorized specialist agents, with explicit permissions and execution limits.

Frontend and Integrations

We used Next.js, React, TypeScript, and Tailwind CSS to build the website, including a visual agent builder, execution graphs, thread management, and run monitoring.

We implemented MCP-based GitHub and Google Drive integrations and an internal request and approval system connecting employees with the Software/AI team.

We also used Docker to coordinate our services and developed tests around agent behavior, authorization, and internal workflows.

Evaluations and Observability

A major part of our design is making agent performance measurable and execution understandable.

Following NMC2's evaluation requirements, we designed our evaluation framework around three key metrics:

Success Rate

$$ \text{Success Rate} = \frac{\text{Successful Runs}}{\text{Eligible Runs}} \times 100\% $$

Tool-Call Accuracy

$$ \text{Tool Accuracy} = \frac{\text{Correct Tool Calls}}{\text{Judged Tool Calls}} \times 100\% $$

Intervention Rate

$$ \text{Intervention Rate} = \frac{\text{Runs Requiring Human Intervention}}{\text{Eligible Runs}} \times 100\% $$

These are intended evaluation metrics, not claimed production performance results. Automated evaluation remains an area of ongoing development.

For observability, our execution console provides visual graphs, timelines, tool activity, and stored run events, making it easier to inspect agent behavior and diagnose failures.

Security and Guardrails

Security became especially important once we shifted NMC3 toward internal enterprise use.

Rather than relying solely on prompt instructions, we incorporated security into the platform architecture.

  • Role-Based Access: Employee roles distinguish requesters, engineers, reviewers, and administrators.
  • Tool Permissions: Deny-by-default configurations restrict which tools and resources agents can access.
  • Delegation Controls: Agent execution limits which specialists can be invoked and how work can be delegated.
  • Approval Workflows: Specifications require authorized review, with decisions tied to specific revisions.
  • Data Protection: Authenticated requests and scoped authorization help restrict access to internal resources.
  • Auditability: Stored records and execution events provide visibility into actions, decisions, and outcomes.

These controls form the foundation of our security model, although further integration and validation would be necessary for production deployment.

Our goal is not simply to make agents more autonomous, but to make that autonomy manageable, observable, and secure.

Challenges we ran into

Understanding the Actual Audience

While developing the application, we decided to attend the NMC2 workshop. Initially, we believed we had a clear understanding of what the challenge statement expected. However, during the workshop, we realized that we had misinterpreted the intended target audience.

Our application originally began as a SaaS platform designed for NMC2 to develop custom agents for external clients, but we have since shifted its focus to serve as an internal tool for NMC2.

This required us to rethink employee roles, permissions, and how work moves between departments.

Connecting Business Workflows with Agent Execution

Building the request and approval system was one challenge, but connecting it with agent definitions, execution, and monitoring was another.

We developed these systems as separate components, and bringing them together into one continuous lifecycle remains an important integration challenge.

Balancing Autonomy, Security, and Accessibility

We also had to determine how agents could safely access tools, delegate work, and operate within resource limits while remaining easy for nontechnical employees to use.

Building an interface powerful enough for developers but simple enough for business analysts and project managers required us to rethink how complex technical capabilities should be presented.

Accomplishments that we're proud of

One of our biggest accomplishments is that we went beyond building a single-purpose AI agent. Instead, we built the foundation for an entire agent orchestration platform.

We are especially proud of:

  • Core Agent Infrastructure: A Go-based API supporting agent definitions, execution, permissions, and run history.
  • Visual Orchestration: An interactive builder and execution console for configuring and observing agent workflows.
  • Enterprise Integrations: MCP-based tool integrations connecting agents to external resources.
  • Internal Collaboration: A role-based system for capability requests, specifications, reviews, and approvals.
  • Security and Monitoring: Guardrails, execution limits, and observable run histories.
  • Adapting Our Product: Restructuring NMC3 around feedback from the NMC2 workshop without abandoning our original agent orchestration concept.

Most importantly, NMC3 is not limited to one department or one use case. Its architecture is designed around reusable agent capabilities that can support many different internal workflows.

What we learned

One of the biggest things we learned is that building an agent and building an agent orchestration platform are two completely different challenges.

Creating an individual agent is relatively straightforward. Managing multiple agents, their permissions, integrations, context, and execution history adds an entirely different level of complexity.

We also learned that technical capabilities alone do not make a product useful. An application designed for software engineers may be powerful, but that does not mean a business analyst or project manager can easily use it.

The NMC2 workshop reinforced the importance of understanding the actual users of a product before building around our assumptions.

Most importantly, we learned that agents become much more useful when integrated into existing business processes rather than treated as separate tools.

What's next for NMC3

Our next step is to unify the API, SDK, and website around the same agent definitions and execution infrastructure.

We plan to expand NMC3 through several areas:

  • Developer SDK and CLI: Complete developer-facing tools for building and managing agents programmatically.
  • Enterprise Integrations: Expand MCP and API integrations, including SerpAPI for research-driven workflows.
  • Shared Context: Improve secure context sharing and memory between agents and departments.
  • Automated Evaluations: Execute repeatable test suites, compare models, and measure agent performance.
  • Workflow Automation: Add scheduling, event-driven triggers, and more advanced orchestration.
  • Enterprise Governance: Strengthen security, approval enforcement, budgeting, and auditing.

Our long-term goal is to make NMC3 a platform where anyone in a company can harness the power of agent orchestration, regardless of their technical background.

GitHub Repository: NMC3

AI-Assisted Development

Throughout development, we utilized a variety of Cursor tools, including Cursor Agent, Composer, Tab, and codebase search, to accelerate development, refactor code, debug issues, and work across our Go backend and Next.js frontend.

We also leveraged frontier Grok models for complex code generation, architectural planning, and problem-solving, allowing us to rapidly prototype and iterate on NMC3 while reviewing and testing the resulting implementations.

Built With

Share this project:

Updates

Submission history