DEV Community

Oscar Ricardo Sánche Gutierréz
Oscar Ricardo Sánche Gutierréz

Posted on

Saltcorn + AI Agents: Build Enterprise Apps Without Boiling the Ocean

#ai #docker #agentskills #nocode

Architecture

Diagram made with https://savnet.co

Asking an AI agent to build a full enterprise system directly in code has a well-known problem: context gets too large.

A form with 4 fields is easy. A system with 60 fields, relationships, permissions, views, forms, calendars, Kanban boards, charts, files and business rules is not. The agent starts hallucinating, forgets previous decisions, duplicates logic or breaks parts of the code it wrote itself.

At Savne we explored another path: using Saltcorn as a no-code canvas.

Saltcorn already provides a stable framework for building applications: tables, fields, views, pages, forms, menus, relationships, permissions and interface plugins. This reduces the mental load and context the AI must maintain. Instead of asking the agent to invent an entire application from scratch, we ask it to operate within an already structured platform.

The problem: Saltcorn doesn't expose a complete enough API for an agent to fluidly build and modify applications.

Enter savne-saltcorn-agent-api.

What is savne-saltcorn-agent-api?

It's a Saltcorn plugin that exposes an administrative API designed for agents, scripts and automation tools.

The idea is not to create a second application layer outside Saltcorn. Saltcorn remains the source of truth.

The plugin allows an agent to:

  • Inspect existing tables, views, pages, plugins and menus
  • Create tables, fields and relationships
  • Insert test data
  • Create List, Show, Edit, Tabulator, Kanban, Calendar and Chart views
  • Create pages and public pages
  • Modify menus in a controlled way
  • Build advanced form layouts
  • Work with many-to-many relationships
  • Create triggers, actions and webhooks (on explicit request)
  • Query an OpenAPI contract
  • Follow a skill designed to reduce errors and dangerous operations

Why this helps AI

When an agent programs everything from scratch, it must keep in context:

  • Database structure
  • Validations
  • Forms
  • Endpoints
  • UI states
  • Permissions
  • Styles
  • Navigation
  • Business rules
  • Dependencies
  • Migrations
  • Internal conventions

With Saltcorn, much of that already exists as a working model. The agent doesn't need to invent a new architecture; it needs to describe concrete operations on Saltcorn.

This reduces the risk of the system ending up split into two fragile layers:

  1. A code layer generated by the AI
  2. A context layer the agent tries to remember

Sooner or later that second layer breaks. With this plugin, Saltcorn stores the real system structure and the API lets you modify it explicitly.

Manual HTML vs Saltcorn request

Suppose we want a simple product form with 4 fields.

In HTML we might start like this:

<form method="post" action="/products">
  <label for="code">Code</label>
  <input id="code" name="code" type="text" required>

  <label for="name">Product</label>
  <input id="name" name="name" type="text" required>

  <label for="stock">Stock</label>
  <input id="stock" name="stock" type="number" min="0">

  <label for="active">Active</label>
  <input id="active" name="active" type="checkbox">

  <button type="submit">Save</button>
</form>
Enter fullscreen mode Exit fullscreen mode

That looks small, but it doesn't include:

  • Database table
  • Persistent validations
  • List view
  • Edit view
  • Permissions
  • Creation modal
  • Menu
  • API
  • Export
  • Relationships with other tables
  • Consistent app styles

With savne-saltcorn-agent-api, the agent asks Saltcorn to create the table:

{
  "name": "products",
  "label": "Products",
  "fields": [
    { "name": "code", "label": "Code", "type": "String", "required": true, "unique": true },
    { "name": "name", "label": "Product", "type": "String", "required": true },
    { "name": "stock", "label": "Stock", "type": "Integer" },
    { "name": "active", "label": "Active", "type": "Bool" }
  ],
  "dry_run": true
}
Enter fullscreen mode Exit fullscreen mode

And then create basic views:

{
  "table": "products",
  "labels": {
    "view": "View",
    "edit": "Edit",
    "delete": "Delete",
    "save": "Save"
  },
  "dry_run": true
}
Enter fullscreen mode Exit fullscreen mode

Instead of spending context generating HTML, backend, routes and persistence, the agent describes the intent. Saltcorn keeps the real model and the plugin offers a safe way to operate on it.

Deploy Saltcorn with Docker

First, let's deploy our Saltcorn instance using Docker and this manifest:

# docker-compose.yml 
services:
  postgres:
    image: postgres:16-alpine
    container_name: saltcorn-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - ./saltcorn_pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - saltcorn_net
    ports:
      - "5432:5432"

  saltcorn:
    image: saltcorn/saltcorn:latest
    container_name: saltcorn-app
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
    command: serve
    environment:
      PGHOST: postgres
      PGPORT: 5432
      PGDATABASE: ${POSTGRES_DB}
      PGUSER: ${POSTGRES_USER}
      PGPASSWORD: ${POSTGRES_PASSWORD}
      SALTCORN_SESSION_SECRET: ${SALTCORN_SESSION_SECRET}
      SALTCORN_FILE_STORE: /opt/saltcorn/files
    volumes:
      - ./saltcorn_files:/opt/saltcorn/files
      - ./saltcorn_external_packages:/opt/saltcorn_external_packages
    ports:
      - "3000:3000"
    networks:
      - saltcorn_net

networks:
  saltcorn_net:
    name: saltcorn_net
Enter fullscreen mode Exit fullscreen mode

We'll also use a .env file for our variables:

#.env

POSTGRES_DB=saltcorn
POSTGRES_USER=postgres
POSTGRES_PASSWORD=Here_password_Strong
SALTCORN_SESSION_SECRET=Here_Secret_random
Enter fullscreen mode Exit fullscreen mode

Once you have both files, run these commands to deploy your new instance:

# Start only Postgres first
docker compose up -d postgres

# Create the database schema
# Type Yes when prompted
docker compose run --rm saltcorn reset-schema

# Restart services
docker compose down          
docker compose up
Enter fullscreen mode Exit fullscreen mode

The above commands only run the first time. After that, a simple docker compose up is all you need.

If everything went well, go to http://localhost:3000 and you should see a screen to create your first Saltcorn user.

Home page

Once your user is created, let's continue with the plugin installation.

Installation from GitHub

In Saltcorn, open (http://localhost:3000/plugins/new):

Setup/Modules -> Add another plugin
Enter fullscreen mode Exit fullscreen mode

Use this data:

Name: savne-saltcorn-agent-api
Source: github
Location: OscarSanchezSavne/savne-saltcorn-agent-api
Version: v0.2.56
Enter fullscreen mode Exit fullscreen mode

To follow the main branch:

Name: savne-saltcorn-agent-api
Source: github
Location: OscarSanchezSavne/savne-saltcorn-agent-api
Version: main
Enter fullscreen mode Exit fullscreen mode

Add module

After installing, restart Saltcorn if the interface doesn't register the routes immediately.

We also recommend these plugins for a better experience:

  • charts
  • flatpickr-date
  • fullcalendar
  • html
  • json
  • kanban
  • leaflet-map
  • many-to-many
  • markdown
  • material-design
  • mermaid
  • money
  • multi-file-upload
  • pivottable
  • qrcode
  • selectize
  • tabulator
  • time-type

If everything went well, you'll see our card:

Card módule

Click the question mark icon to find the OpenAPI and Swagger spec URLs for more information:

Info plugin

Administrative operations require a Saltcorn user token:

Authorization: Bearer <saltcorn-user-api-token>
Enter fullscreen mode Exit fullscreen mode

You can get it from your user settings at http://localhost:3000/auth/settings. Remember, the token must belong to an admin user:

Create token

Integrating with your AI Agent

To teach your agent how to use Saltcorn, download our skill:

How to integrate depending on your agent:

  • Claude Projects / Custom GPTs / Copilot: copy the SKILL.md content directly into the agent's system instructions.
  • API agents (OpenAI, Anthropic, etc.): pass the content as a system message (system role) at the start of each conversation.
  • n8n / Make / automations: use the file as the base prompt for the AI node.

The skill defines:

  • Which endpoints to call based on intent
  • What parameters to send
  • What not to do (dry_run first, no deleting without permission, etc.)
  • How to interpret the plugin's responses

Without this skill, the agent operates blindly. With it, it knows exactly how to behave.

From prompt to app in minutes

Example 1 — Inventory system:

"Build an inventory app with products, categories, and inbound/outbound movements. Each product should have a code, name, stock, and price. I want a Kanban view by category and a calendar for movements."

The agent interprets the prompt, inspects the current Saltcorn state, plans tables and views, and creates them step by step with dry_run: true so you can review before executing.

Example 2 — Public survey with validation:

"I need a public employee satisfaction survey. Store responses anonymously, but prevent duplicates by IP within 24 hours. If the overall score is below 3, send a webhook to a Slack channel."

Closing

It's not about replacing Saltcorn with AI.

It's about giving AI a stable framework to operate within.

Saltcorn provides the no-code structure. savne-saltcorn-agent-api provides a safe, documented API designed for agents. The skill provides the usage rules so the agent doesn't have to guess.

The result is a more reliable way to build small and medium-sized systems with AI assistance, without forcing the end user to become a programmer and without asking the agent to hold the entire system in memory as if by magic.

Related links:

Top comments (0)