Skip to content

avoguru/not7-core

BranchesTags

Repository files navigation

NOT7 - Not Your Typical Agent

NOT7 Logo

License: MIT Go Version

A single-binary declarative agent runtime. No code. No dependencies. Just intelligence.

Vision

NOT7 is a config-driven agent runtime delivered as a single binary. Agents are defined as declarative JSON configurations and executed with zero dependencies. No programming languages. No installations. Just drop the binary, declare your agent in JSON, and run.

Architecture Overview

            ┌───────────────────────────────┐
            │     USER / DEVELOPER          │
            └───────────────┬───────────────┘
                            ↓
            ┌───────────────────────────────┐
            │   JSON Agent Definition       │
            │   (nodes, routes, config)     │
            └───────────────┬───────────────┘
                            ↓
            ┌───────────────────────────────┐
            │   NOT7 CORE RUNTIME           │
            │   Executor Engine             │
            └───────────────┬───────────────┘
                            ↓
        ┌───────────────────┼───────────────────┐
        ↓                   ↓                   ↓
┌───────────────┐  ┌────────────────┐  ┌───────────────┐
│ LLM Provider  │  │ Tool Providers │  │    Storage    │
│               │  │                │  │               │
│ - OpenAI      │  │ - Native       │  │ - Executions  │
│ - GPT-4/3.5   │  │ - Arcade       │  │ - Traces      │
│               │  │   (Gmail, Maps)│  │ - Logs        │
└───────────────┘  └────────────────┘  └───────────────┘

Table of Contents

Why NOT7?

The Problem with Current Agentic Frameworks

Today's agentic landscape is fragmented and inaccessible. Frameworks like LangGraph and LangChain are powerful but language-dependent - you must write Python or Node.js code. Installation is complex, dependencies break, and despite how fascinating and useful these tools are, non-technical users cannot easily get started. The barrier to entry remains high.

On the other end of the spectrum, no-code platforms (n8n, Zapier, Make) promise simplicity but deliver rigidity. You define workflows through visual interfaces, which seems appealing until you realize you're locked into that vendor's abstractions. Over time, your agents become tightly coupled to proprietary systems. There's no neutral ground - nothing that's both simple AND extensible.

The Missing Middle Ground

The industry needs something between these extremes. Not too technical and program-dependent on one side. Not too rigid and vendor-locked on the other. A sweet spot that is:

  • Declarative (like no-code simplicity)
  • Simple (anyone can read JSON)
  • Extensible (anyone can build UIs or tooling on top)
  • LLM-compatible (AI can generate and evolve specs, vs having to generate the whole python / node projects)

NOT7 Architecture

Learning from Integration Platforms

If you look at the integration and ESB space in the past, they got something fundamentally right: transparent XML or JSON-based workflow definitions. You could open the file, read it, understand it, debug it. The definition WAS the documentation.

Current agentic frameworks abandoned this clarity. They've built hidden graph abstractions that become black boxes. Complex internal state machines, opaque routing logic, workflows you can't easily inspect. When something goes wrong, you're debugging code, not reading specifications.

NOT7 returns to the integration platform philosophy: transparent, declarative definitions. But we evolve it further. Instead of static workflow definitions, we embrace evolution through versioning. Different JSON versions become your visibility layer. Each version is a complete, inspectable snapshot. Want to know why your agent behaved differently? Compare v3 to v5. Want to debug? Read the JSON. Want to understand evolution? Trace through versions.

The versioning IS the intelligence. The transparency IS the debuggability.

This is the evolutionary next stage of integration platforms - applied to agentic systems. Taking what worked (transparent definitions) and adding what's needed (evolutionary optimization).

Key Features

Config-Driven Single binary with simple configuration file. No programming languages to install.

Declarative JSON Agents are pure JSON specifications. No code required.

LLM-Native JSON specs are trivial for LLMs to generate. AI writes specs, NOT7 executes them.

Multi-Tool Orchestration Use multiple tool providers in a single agent. Each node can have its own toolkit configuration.

Transparent Evolution Version your agent specs. See exactly how your agent evolved from v1 to v10.

Production Ready Server mode with HTTP API and deploy folder watching. Structured logging for observability.

Zero Dependencies Download one binary and run. Works on macOS, Linux, Windows.

Quick Start

macOS (Apple Silicon):

curl -L https://github.com/not7/core/raw/main/dist/not7-darwin-arm64 -o not7
chmod +x not7
cp not7.conf.example not7.conf
# Edit not7.conf: Add your OPENAI_API_KEY
./not7 run examples/camera-research.json

macOS (Intel) / Linux / Windows: See dist/ folder for other platform binaries.

Try the Arcade Integration (Google Maps + Gmail):

# Setup Arcade.dev credentials in not7.conf
# ARCADE_API_KEY=your-key
# ARCADE_USER_ID=your-user-id

# Authorize Google services
./not7 authorize

# Run lunch recommendations demo (update email in JSON first!)
./not7 run examples/arcade-lunch-demo.json

That's it! The agent executes and generates output.

API Reference

NOT7 provides a full REST API for managing and executing agents.

Deploy & Manage Agents

Deploy Agent (without executing):

POST /api/v1/agents
Content-Type: application/json

{
  "id": "my-agent",
  "version": "1.0.0",
  "goal": "Do something",
  "nodes": [...],
  "routes": [...]
}

List All Agents:

GET /api/v1/agents

Get Agent:

GET /api/v1/agents/{id}

Update Agent:

PUT /api/v1/agents/{id}
Content-Type: application/json

{ ...updated agent spec... }

Delete Agent:

DELETE /api/v1/agents/{id}

Execute Agents

Execute Deployed Agent:

POST /api/v1/agents/{id}/run

Execute Anonymous Agent (no save):

POST /api/v1/agents/run
Content-Type: application/json

{ ...agent spec... }

Example Workflow

# 1. Deploy an agent
curl -X POST http://localhost:8080/api/v1/agents \
  -H "Content-Type: application/json" \
  -d @examples/poem-generator.json

# 2. List agents
curl http://localhost:8080/api/v1/agents

# 3. Run agent (can trigger multiple times)
curl -X POST http://localhost:8080/api/v1/agents/poem-generator/run

# 4. Update agent
curl -X PUT http://localhost:8080/api/v1/agents/poem-generator \
  -H "Content-Type: application/json" \
  -d @examples/poem-generator-v2.json

# 5. Delete agent
curl -X DELETE http://localhost:8080/api/v1/agents/poem-generator

Example Agent

Simple poem generator:

poem-generator.json:

{
  "version": "1.0.0",
  "goal": "Generate a poem about AI agents",
  
  "config": {
    "llm": {
      "provider": "openai",
      "model": "gpt-4",
      "temperature": 0.9
    }
  },

  "nodes": [
    {
      "id": "generate_poem",
      "type": "llm",
      "prompt": "Write a creative poem about AI agents...",
      "output_format": "text"
    }
  ],

  "routes": [
    {"from": "start", "to": "generate_poem"},
    {"from": "generate_poem", "to": "end"}
  ]
}

Run:

not7 run poem-generator.json

Output:

NOT7 - Agent Runtime
====================

📖 Loading spec: poem-generator.json
✓ Spec loaded successfully

🚀 Starting agent: Generate a poem about AI agents
📋 Version: 1.0.0

⚙️  Executing node: Generate Poem About Agents (llm)
   ✓ Completed in 2850ms (cost: $0.0275)

✅ Execution completed in 2850ms
💰 Total cost: $0.0275

📄 Output:
─────────────────────────────────────
[Your generated poem appears here]
─────────────────────────────────────

💾 Results saved to: poem-generator.json.result.json

Building from Source

Prerequisites

  • Go 1.21 or higher
  • Make

Build

git clone https://github.com/not7/core.git
cd core
cp not7.conf.example not7.conf
# Edit not7.conf with your API key
make build
./not7 run examples/poem-generator.json

Build for All Platforms

make build-all

Creates binaries in dist/ for macOS, Linux, Windows.

Tool Integration

✅ Arcade.dev Integration (Available Now)

NOT7 integrates with Arcade.dev for pre-built tool integrations:

  • Gmail - Send, draft, search, delete emails
  • Google Calendar, Maps, Contacts, Docs, Drive, Sheets, Slides - Full suite of Google services
  • Per-Node Toolkit Configuration - Use multiple toolkits in a single agent

Single Toolkit Example

{
  "config": {
    "tools": {
      "provider": "arcade-gmail"
    }
  },
  "nodes": [{
    "type": "react",
    "tools_enabled": true,
    "react_goal": "Send an email summarizing the analysis"
  }]
}

Multi-Toolkit Example (Per-Node Configuration)

Use different toolkits in different nodes:

{
  "config": {
    "llm": {
      "provider": "openai",
      "model": "gpt-4o"
    }
  },
  "nodes": [
    {
      "id": "find-restaurants",
      "type": "react",
      "tools_enabled": true,
      "config": {
        "tools": {
          "provider": "arcade-googlemaps"
        }
      },
      "react_goal": "Find 3 lunch restaurants in San Francisco"
    },
    {
      "id": "format-email",
      "type": "llm",
      "prompt": "Format the restaurant list as a clean email"
    },
    {
      "id": "send-email",
      "type": "tool",
      "config": {
        "tools": {
          "provider": "arcade-gmail"
        }
      },
      "tool_name": "SendEmail",
      "tool_arguments": {
        "recipient": "user@example.com",
        "subject": "Lunch Recommendations",
        "body": "{{input}}"
      }
    }
  ],
  "routes": [
    {"from": "start", "to": "find-restaurants"},
    {"from": "find-restaurants", "to": "format-email"},
    {"from": "format-email", "to": "send-email"},
    {"from": "send-email", "to": "end"}
  ]
}

Multi-Toolkit Workflow:

┌─────────────────────────────────────────────────────────────┐
│  Agent: Lunch Recommendations                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Node 1: find-restaurants                                  │
│  ┌─────────────────────────────────┐                       │
│  │ Type: react                     │                       │
│  │ Tools: arcade-googlemaps  ◄─────┼─── Google Maps API   │
│  │ Goal: Find 3 restaurants        │                       │
│  └─────────────────────────────────┘                       │
│              ↓                                              │
│  Node 2: format-email                                      │
│  ┌─────────────────────────────────┐                       │
│  │ Type: llm                       │                       │
│  │ Provider: OpenAI          ◄─────┼─── OpenAI API        │
│  │ Prompt: Format nicely           │                       │
│  └─────────────────────────────────┘                       │
│              ↓                                              │
│  Node 3: send-email                                        │
│  ┌─────────────────────────────────┐                       │
│  │ Type: tool                      │                       │
│  │ Tools: arcade-gmail       ◄─────┼─── Gmail API         │
│  │ Tool: SendEmail                 │                       │
│  └─────────────────────────────────┘                       │
│              ↓                                              │
│  Output: Email sent with recommendations                   │
└─────────────────────────────────────────────────────────────┘

3 Nodes × 3 Different Providers = Multi-Toolkit Orchestration

Key Features:

  • Node-level override: Each node can specify its own toolkit
  • Tool manager pooling: Same toolkit reused across nodes (efficient)
  • arcade-{toolkit} pattern: Clear, explicit toolkit naming (e.g., arcade-gmail, arcade-googlemaps)

Setup:

# Add to not7.conf
ARCADE_API_KEY=your-api-key
ARCADE_USER_ID=your-user-id

# Authorize (one-time interactive OAuth)
./not7 authorize

Roadmap

Tool Integration - Next Steps MCP protocol support for external tools (databases, APIs, file systems)

Dynamic Routing
LLM-driven path selection at runtime for autonomous agent flow

Scale & Performance
Parallel execution and concurrent agent processing

Provider Ecosystem
Support for multiple LLM providers (Anthropic, local models, custom endpoints)

Production Hardening
Security, Agent authorization, rate limiting, monitoring capabilities

License

MIT License - see LICENSE file for details.

Contribution

Willing to contribute ? Or Learn ? Ping me - https://www.linkedin.com/in/gnanaguru/

About

A single-binary declarative agent runtime. No code. No dependencies. Just intelligence.

Resources

Readme

License

MIT license
Activity

Stars

6 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Languages