Source-available application infrastructure and adaptable social software for ChatGPT Sites.

AittaDB develops independent infrastructure, tools, and applications for persistent, authenticated software running on OpenAI-hosted ChatGPT Sites.

At its center is AittaDB: a reusable application backend providing identity, data, files, and events through one self-contained deployment. The organization also develops AittaSocial, the platform and product family for the developing Aitta Network.

These projects are experimental, under active development, independent of OpenAI, and not official OpenAI products.

These boundaries are deliberate. AittaDB provides small, reusable backend primitives. AittaSocial, the Hub, and other applications own their product-specific behavior, interfaces, and policies.

An Aitta currently stores its own identity, publishing data, and configuration in its deployment-owned D1 database. It does not require a separate AittaDB instance or a shared Hub content store. The Hub may use AittaDB for bounded central state without moving authority over independently controlled Aitta content into the Hub.

An Aitta is one independently controlled top-level place in the Aitta Network.

It may represent a person, company, project, community, publication, AI agent, or another kind of entity. It may be public, private, connected to the Hub, or operated independently.

An Aitta is not merely one app, profile, feed, or conversation. It is the place that can contain:

• its identity and outward profile;
• messages and other typed events;
• people, memberships, and access policies;
• trusted, versioned app implementations;
• concrete app instances and their state;
• conversations and nested app spaces;
• locally authoritative and locally retained data;
• its own appearance, behavior, address, configuration, and runtime.

An Aitta deployment is one running installation of an Aitta. The current proof of concept runs one Aitta per ChatGPT Sites deployment.

The Aitta Network is the developing network of Aittas and participating members.

A future member may join, follow, communicate, and participate without owning or deploying an Aitta. Network membership, Aitta ownership, deployment administration, and content authority remain separate concepts.

The longer-term network model is based on typed events and recursively composable app spaces:

• Every event has a globally unique identity and a documented type.
• An event may participate inside one app space while becoming the root of another.
• A message may contain a discussion, question, task, or another app.
• An app may contain messages, restricted working spaces, and further nested apps.
• The parent relationship describes structure; the event type describes meaning.
• Parentage alone never grants discovery, membership, read access, write access, delivery, or notification rights.
• Each event, state transition, draft, cache, and local projection has an explicit authority.
• A root Aitta does not automatically become the author of every descendant event.
• Feeds and threads are ordered projections of events, not the underlying authority or storage model.

A nested app space may feel like a small place within an Aitta, with its own purpose, members, activity, permissions, and apps. It is not itself an Aitta unless it has a separate top-level deployment, authority, address, and lifecycle.

An app implementation is trusted, versioned software installed independently in an Aitta.

A message or event may identify an app type, carry validated data, refer to state, and request supported actions. It must not carry executable JavaScript, arbitrary HTML, remote scripts, or automatically installed software.

The same logical app may appear in several Aittas while each Aitta keeps different permitted local state. The app contract must distinguish:

• state controlled by the originating Aitta;
• events controlled by their individual authors;
• participant-controlled state;
• local-only drafts, viewed state, and notifications;
• synchronized, cached, or derived state;
• revocation and conflict behavior.

When an Aitta encounters an unsupported app type, it must fail safely. It may show bounded static information or a compatible web fallback, but it must never automatically execute the sender’s implementation.

One planned Aitta Network loop is App Idea:

1. A member describes a real need.
2. Other people add examples, requirements, questions, and testing interest.
3. An agent helps turn the discussion into a bounded specification.
4. Aitta’s development agents prepare implementation changes through normal source control.
5. Tests, compatibility checks, security review, and human approval precede release.
6. Compatible Aittas receive the trusted implementation through an approved platform update.
7. The running app can collect further feedback and improvement ideas.

AI assistance may configure trusted capabilities or prepare reviewed source changes. It must not distribute arbitrary generated code through network events.

This is future product direction, not a claim about the current proof of concept.

The current AittaSocial proof of concept supports:

• one independently controlled Aitta per deployment;
• a configurable, category-neutral identity profile;
• notes, articles, links, and announcements;
• drafts and publishing;
• public update permalinks;
• deployment-owned D1 persistence;
• a public discovery manifest;
• versioned JSON resources;
• basic presentation controls;
• sole-owner administration through Sign in with ChatGPT.

It does not yet provide:

• Aitta Network membership;
• participation without Aitta ownership;
• a working Hub connection;
• invitations;
• verified network discovery;
• Follow and Unfollow;
• the Your network reader;
• recursive event-rooted app spaces;
• direct messaging;
• App Ideas;
• distributed trusted-app delivery.

These capabilities remain staged, contract-dependent direction rather than shipped features or release commitments.

The working product promise is:

A place that grows around what people do together.

The working campaign line is:

Start with a message. Let it grow.

The current AittaDB development preview includes:

• ChatGPT-based upstream identity mapped to a separate local AittaDB identity;
• OAuth 2.0 and OpenID Connect sessions for connected applications;
• persistent structured JSON data;
• object and file storage;
• immutable typed-event publication, bounded reads, and cursor-based long polling behind a feature flag;
• human-facing HTML interfaces and versioned hypermedia JSON representations;
• HTTP APIs for websites, services, command-line tools, native applications, and AI agents.

AittaDB deliberately provides general-purpose primitives rather than embedding social-network, investor-management, payment, membership, or other product-specific workflows into the database server.

The goal is to let developers build persistent, authenticated applications without first deploying and maintaining a conventional application server, database server, object-storage service, and authentication service.

The current AittaDB and AittaSocial implementations are designed for ChatGPT Sites.

They use supported platform capabilities including:

• managed application hosting and runtime;
• Sign in with ChatGPT;
• D1 storage for persistent structured data;
• R2 object storage where required;
• hosted configuration and secrets.

A core AittaDB deployment can therefore provide a reusable backend without requiring a separate conventional infrastructure stack. Each deployment remains independently configured and has its own users, data, credentials, keys, and storage.

Supported capabilities, availability, and limits depend on the current ChatGPT Sites platform, account, plan, region, and workspace configuration. Consult the official documentation rather than assuming fixed platform limits.

In Finnish, an aitta is a traditional detached storehouse on a farmstead. It was built to keep grain, food, tools, and other valuable supplies safe and available.

AittaDB follows the same idea for software infrastructure: a dependable place for an application’s identity, data, files, and events.

Within AittaSocial, an Aitta carries the idea further. It is an independently controlled place where an identity, its people, conversations, data, and trusted apps can live and grow while choosing how—and whether—to participate in the wider network.

The projects are under active development. Their interfaces, protocols, terminology, and operational requirements may change before stable releases.

Current public AittaDB and AittaSocial releases use the source-available FSL-1.1-MIT license. Each released version converts to the MIT License two years after publication. Consult each repository’s license for its exact terms.

Describe a current FSL release as source-available, not open source. A version that has converted to MIT, or is separately licensed under MIT, is open-source software under the MIT License.

You can contribute by:

• deploying and testing AittaDB or AittaSocial;
• trying an Aitta with a real project or small group;
• reporting bugs and compatibility problems;
• proposing real-world needs and App Ideas;
• improving documentation, accessibility, and public protocols;
• reviewing security, privacy, authority, and access-control boundaries;
• developing client libraries, integrations, and command-line tools;
• helping define and test trusted app implementations;
• submitting focused pull requests;
• supporting the projects as an early investor.

Please read the contribution and agent instructions in each repository before making changes.

AittaDB is currently in its pre-startup stage. I am open to conversations with people interested in supporting AittaDB, AittaSocial, and the developing Aitta Network as early startup investors.

This is currently a friends-and-family-style phase—although I am open to making new friends who believe in the idea.

This is an invitation to start a conversation, not an announcement of a formal funding round or securities offer. Interested people can contact me through my GitHub profile or LinkedIn.

• Read the customer-facing Aitta Network introduction
• Explore AittaSocial and the developing Hub
• Visit the live AittaDB development service
• Browse the AittaDB GitHub organization
• Use GitHub Issues for bug reports and focused proposals
• Read the official ChatGPT Sites documentation
• Visit the founder’s GitHub profile: @thejhh