Get Started
The Premise Language

Less code.
More intelligence.

Premise is a cognitive language designed so that agents, services, concurrency, and messaging are core elements of its syntax—not external libraries. Write 20 lines where Java needs 98.

Explore The Platform
0

Lines to express concurrent TCP in Premise

0 x

Less code than Java for identical behavior

0

Import statements
required

0

Languages benchmarked head-to-head

Stigmergic Agent Language

A Language Built For The Age Of Intelligent Machines.

Premise is a stigmergic agent language—designed to express, in a clear and natural way, how intelligent systems are able to coordinate, communicate, and act collaboratively without the need for centralized control or oversight.

Most programming languages were designed for a world of files, functions, and data structures. Premise was designed for a different world — one where software thinks, learns, communicates, and acts autonomously.

It is the native language of the SubThought cognitive platform, purpose-built to express agent behavior, service orchestration, and machine intelligence with radical simplicity. Where other languages require you to assemble intelligence from parts, Premise lets you describe it directly.

In contrast to languages like Python or Java, which require explicit construction of data pipelines, state machines, and message-passing frameworks, Premise empowers users to describe complex agent behaviors in a few concise statements.
 
This results in not only faster development cycles but also more adaptable and maintainable systems. The language is designed to evolve alongside advances in cognitive computing, making it a forward-thinking choice for next-generation autonomous software.
Key Features

Expressive By Design

Premise reads closer to how you'd describe intelligent behavior in plain language. Agents, services, messaging, and concurrency are native constructs — not patterns you assemble from libraries.

Radical Brevity

What takes 98 lines in Java takes 20 in Premise. Less code means fewer bugs, faster iteration, and logic that's easier to reason about and maintain.

Built-in Concurrency

Parallel agents and services run with a single concurrent primitive. No threads to manage, no async plumbing, no race conditions to debug.

Java Interoperability

Premise runs on the JVM and interoperates directly with Java via the \@j{...} escape — giving you the full power of the Java ecosystem without the ceremony.

By The Numbers

The same program. Drastically fewer lines.

We implemented the same concurrent TCP ping-pong agent in five languages. The results speak plainly.

Premise — Lines of Code Comparison (Language Colors)
Lines of Code — Concurrent TCP Ping-Pong Agent
Premise
20 lines
baseline
Python
55 lines
2.8×
TypeScript
72 lines
3.6×
Go
82 lines
4.1×
Java
98 lines
4.9×
Premise
Python
TypeScript
Go
Java
See The Difference

The Proof Is In The Code.

Every tab shows the exact same program — a concurrent TCP ping-pong agent — written in a different language. Switch tabs and see for yourself.

Premise — Code Comparison (100% width)
ping_pong.premise Premise
Agent/service primitives are built into the language. Networking, concurrency, and messaging are intrinsic.
async_tcp.py Python 3.12
asyncio provides clean async TCP, but you still wire up streams, buffers, and connection lifecycle manually.
tcp_net.ts TypeScript 5.4
Node.js net module handles TCP, but Promises and callbacks create structural overhead around each connection.
tcp_ping.go Go 1.22
Goroutines give natural concurrency, but explicit error checking at every I/O call and manual buffer allocation add bulk.
PingPong.java Java 21
Verbose socket setup with wrapper streams. Thread management, try-with-resources, and class ceremony dominate.
Same program. Same behavior. Premise: 20 lines. Java: 98.
GitHub → Books →
What Premise Collapses

Every Concern. One Primitive.

Other languages require separate socket setup, stream wrappers, thread management, and cleanup. Premise handles all of it intrinsically.

Premise — Every Concern. One Primitive.
Concern
In Premise
In other languages
TCP setup
url scheme tcp port N
Server/Socket constructors, bind, listen, accept
Send + reply
ask ?url "ping "
write() → read() with buffer alloc + decode
Reply to sender
tell ?sender "pong "
Get output stream, write, flush, handle errors
Concurrency
concurrent (...)
Thread / goroutine / async task + sync primitives
Agent loop
agent + thunk + delay
setInterval / time.Sleep / Thread.sleep loop
Cleanup
Automatic on cancel
close(), server.close(), clearInterval, defer…
Imports
None
3–6 import statements per file
Type ceremony
None
Class declarations, main signature, type annotations
Premise's primitives collapse what other languages spread across multiple layers of boilerplate.
GitHub → Books →

Premise’s agent, service, ask, tell, and concurrent primitives collapse what other languages spread across socket setup, stream wrappers, thread management, synchronization, and cleanup. The Premise version is 20 lines—the Java equivalent is 98, nearly 5x as much code for identical behavior.

Why Premise?

Built For Cognitive Systems.
Not Adapted For Them.

General-purpose languages weren’t designed with agents in mind… Premise was.

Intrinsic Networking

TCP, messaging, and service endpoints are first-class syntax — no library imports, no boilerplate configuration.

Native Concurrency

The concurrent primitive runs agents and services in parallel without threads, locks, or async/await overhead.

Agent Primitives

agent, service, ask, and tell are the language — not add-ons bolted on after the fact.

Zero Ceremony

No class declarations. No main() boilerplate. No import chains. Start expressing logic from line one.

Automatic Lifecycle

Connections, buffers, and cleanup are managed by the runtime. cancel (self) ends an agent cleanly — no deferred closures required.

Interop Ready

The \@j{...} escape hatch drops into Java expressions wherever needed — no walls between worlds.

Ready To Build Machines That Think?

Explore the Premise source, read the documentation, or pick up the books.

Talk To Us

GitHub

SubThought/Premise

Source code, examples & docs.

Amazon Books

The Premise Language

Learn from the authors.

Platform

Mind Server

See Premise in production.
Cart (0 items)