TLL OS is an AI-Native universal application development protocol. Not a framework. Not a CMS. A unified protocol that both humans and AI Agents can read, understand, and execute.
A protocol, not a framework. A shared language for humans and AI to build software together.
Because the next generation of software won't be written by humans alone. It will be co-developed by humans and AI Agents — and they need a shared protocol.
A machine-readable map of your entire application — modules, APIs, models, events, dependencies. AI doesn't search through files. It reads the Graph.
Agents are first-class citizens. They can discover modules, create APIs, run tests, fix bugs, and propose changes — all through standard contracts, never touching internals.
Don't rebuild what exists. Connect Shopify, WordPress, Medusa, Laravel, any system through Adapters. Migrate, sync, or coexist — your choice.
First-party Modules ship with your app. Third-party Plugins install at runtime. Both follow the same contract. Both are visible in the Application Graph.
One application model. Build for Web, H5, APK, EXE, Mini Program, AI Agent, Industrial, IoT. Projection turns the Graph into any target.
TEP lets any developer or Agent propose changes. Auto-test, AI review, human review, merge. The protocol evolves with its community.
An Agent that has never seen TLL OS source code can build a complete application using only the public protocol.
# 1. Agent connects to TLL OS, reads Application Graph
$ tll graph read
→ 16 nodes, 14 edges, 2 modules
# 2. Agent discovers available capabilities
$ tll capability list
→ product_catalog, payment, authentication, ...
# 3. Agent creates a new Module
$ tll module create inventory
→ Module "inventory" registered in Graph
# 4. Agent creates API endpoints
$ tll api create --module inventory --path /api/items --method GET
$ tll api create --module inventory --path /api/items --method POST
# 5. Agent creates data models
$ tll model create --module inventory Item --fields sku,name,quantity
# 6. Agent writes and runs tests
$ tll test run --module inventory
→ 8/8 passed
# 7. Agent finds a bug, fixes it, re-tests
$ tll test run
→ 7/8 passed, 1 failed
$ tll fix --test api.item_crud
$ tll test run
→ 8/8 passed
# 8. Agent builds for target platform
$ tll build --target web
→ Build successful: dist/web/
TLL OS provides a complete set of machine-readable endpoints. An Agent can discover the protocol, read contracts, browse examples, and understand capabilities — all without reading source code.
From zero to running application in minutes.
# Install TLL OS CLI
$ npm install -g @tll/os-cli
# Create a new application
$ tll new my-app
✓ Created application "my-app"
✓ Application Graph initialized
✓ Runtime adapter: node
# Enter the project
$ cd my-app
# Create a module
$ tll module create hello
✓ Module "hello" registered
✓ Graph updated: +3 nodes, +2 edges
# Add an API endpoint
$ tll api create --module hello --path /api/hello --method GET --handler "return { message: 'Hello TLL OS' }"
✓ API endpoint created
✓ Graph updated: +1 node, +1 edge
# Run tests
$ tll test
→ 3/3 passed
# Start development server
$ tll serve
→ TLL OS running at http://localhost:3000
→ GET /api/hello → { "message": "Hello TLL OS" }
You don't have to start from scratch. Adapters connect mature systems into TLL OS.
Connect your Shopify store. Read products, orders, customers. Migrate to native TLL OS modules when ready.
Connect WordPress content. Read posts, pages, media. Use TLL OS agents to manage and extend your content.
Connect open-source commerce platforms. Sync data, share capabilities, build unified experiences.
Build a custom Adapter for any REST/GraphQL/SOAP/SDK system. The Adapter contract makes it straightforward.
# Install Shopify Adapter
$ tll adapter install shopify
# Configure connection
$ tll adapter configure shopify \
--store mystore.myshopify.com \
--token shpat_xxxxxxxxxxxx
# Connect and read data into Application Graph
$ tll adapter connect shopify
→ Connected to Shopify (API version 2024-07)
→ Synced: 142 products, 89 orders, 234 customers
→ Graph updated: +465 nodes, +892 edges
# Now TLL OS agents can work with your Shopify data
$ tll graph query --type model --name Product
→ 142 Product nodes found
# Or migrate to native TLL OS module
$ tll adapter migrate shopify --entity Product --target-module catalog
→ Migrated 142 products to module:catalog
→ Generated models, APIs, tests
→ 8/8 tests passed
TLL OS evolves through its community. Humans and AI Agents can both propose changes.
Create a first-party module following the Module Contract. Publish it so any TLL OS application can install it.
Create a runtime-installable plugin. Extend any TLL OS application without modifying core code.
Connect a new external system. Follow the Adapter Contract + Compatibility Manifest. The ecosystem grows with every adapter.
Found a bug? Have an idea for a new contract? Submit a TLL Evolution Proposal. Auto-test, AI review, human review, merge.
Protocol 2.0 is frozen. Runtime 0.1 is ready. The ecosystem is waiting for you.