At NOMOS, we believe that the future of AI agent development lies in structured, auditable, and collaborative approaches. Our philosophy is built on the fundamental principle that AI agents should be as testable, maintainable, and reliable as traditional software.

​
The Problem with Current Approaches

Limitations of Prompt-Based Agent Frameworks

While frameworks like LangChain and CrewAI enable rapid AI agent development, they rely heavily on prompt-based approaches that present significant challenges for enterprise applications.

Lack of Determinism

Prompt-based agents are unpredictable—small wording changes can cause major shifts in behavior, making them unreliable for production.

Monolithic Architecture

Massive prompts bundle all logic and tools, making agents hard to manage and debug.

Testing Challenges

Prompt-based agents are hard to test, so quality and reliability can’t be guaranteed.

Collaboration Barriers

Prompt-based agents make teamwork difficult—small changes can break things, blocking effective collaboration.

​
The NOMOS Approach: LLMs + State Machines

Core Philosophy: Structured Intelligence

NOMOS combines the intelligence of Large Language Models with the reliability and predictability of state machines, creating agents that are both powerful and auditable.

​
Key Principles

Break Down Complexity

Divide complex agent tasks into discrete, manageable steps rather than relying on monolithic prompts. Each step has a clear purpose and defined boundaries.

Benefits:

  • Easier debugging and maintenance
  • Clearer logic flow
  • Reduced cognitive load for developers

​
Design Principles

​
1. Progressive Complexity

1

No-Code Prototyping

Start with visual flow design in our Playground for rapid iteration and stakeholder collaboration.

2

Configuration-Driven Development

Move to YAML configuration for more control while maintaining simplicity and team collaboration.

3

Full Programming Control

Utilize the complete Python API when maximum flexibility and customization are required.

​
2. Separation of Concerns

Business Logic

Define what the agent should do independently from how it communicates or which tools it uses.

Tool Integration

Manage tool access and configuration separately from business logic, enabling reusability and security.

Flow Control

Handle step transitions and state management as distinct concerns from content generation.

​
3. Team Collaboration

Multi-Disciplinary Development

NOMOS enables product managers, domain experts, and developers to work together effectively by providing appropriate abstraction levels for each role.

  • Product Managers: Visual flow design and high-level behavior specification
  • Domain Experts: Step-by-step process definition and validation
  • Developers: Tool integration, custom logic, and deployment

​
4. Production Readiness

Enterprise Standards from Day One

Built with enterprise requirements in mind, featuring session management, error handling, monitoring, and scalable deployment options.

​
Philosophy in Practice

​
Traditional Approach

"You are a customer service agent. Your goal is to help customers with their inquiries.
You have access to these tools: [order_lookup, refund_processor, escalation_tool, payment_handler, inventory_check].
When a customer asks about their order, first check the order status using order_lookup,
then if there's an issue use refund_processor to process refunds, but only if the order is older than 30 days unless it's a defective product, then use escalation_tool for complex cases..."

​
NOMOS Approach

name: customer_service
persona: "You are a helpful customer service agent..."
start_step_id: identify_intent

steps:
  - step_id: identify_intent
    description: "Understand customer needs and categorize their request"
    available_tools: []
    routes:
      - target: check_order
        condition: "Customer has an order inquiry"
      - target: validate_refund
        condition: "Customer wants a refund"

  - step_id: check_order
    description: "Look up and verify order details"
    available_tools: [order_lookup]
    routes:
      - target: provide_status
        condition: "Order found successfully"
      - target: escalate_support
        condition: "Order not found or issues detected"

​
Real-World Example: Coffee Shop Assistant

Here’s how a real coffee ordering agent looks in NOMOS:

name: barista
persona: |
  You are a helpful barista assistant at 'Starbucks'. You are kind and polite.
  When responding, you use human-like natural language, professionally and politely.
start_step_id: start

steps:
  - step_id: start
    description: |
      Greet the customer and ask how can I help them.
      Use the `get_available_coffee_options` tool to get the available coffee options if needed.
      When the customer is ready to order, move to the `take_coffee_order` step.
    available_tools:
      - get_available_coffee_options
    routes:
      - target: take_coffee_order
        condition: Customer is ready to place a new order

  - step_id: take_coffee_order
    description: |
      Ask the customer for their coffee preference and size.
      Use tools to manage the cart based on customer requests.
      If the customer wants to finalize the order, move to the `finalize_order` step.
    available_tools:
      - get_available_coffee_options
      - add_to_cart
      - remove_item
      - clear_cart
    routes:
      - target: finalize_order
        condition: User wants to finalize the order
      - target: end
        condition: Customer wants to cancel the order

  - step_id: finalize_order
    description: |
      Get the order summary and inform the customer about the total price.
      Get confirmation from the customer and complete the order.
    available_tools:
      - get_order_summary
      - finalize_order
    routes:
      - target: end
        condition: Order is finalized or canceled
      - target: take_coffee_order
        condition: Customer wants to change the order

tools:
  tool_files:
    - barista_tools.py

Notice how this structure provides:

  • Clear Separation: Each step has a specific purpose and limited tool access
  • Controlled Flow: The agent can only move between explicitly defined routes
  • Testability: Each step can be tested independently
  • Maintainability: Changes to ordering logic don’t affect greeting or payment steps

​
Our Vision for AI Development

The Future is Structured

We envision a world where AI agents are developed with the same rigor, reliability, and collaborative practices as traditional software—without sacrificing the power and flexibility that makes AI transformative.

By combining the best of both worlds—AI intelligence and software engineering practices—NOMOS enables teams to build AI agents that are not just powerful, but also trustworthy, maintainable, and ready for enterprise deployment.