AI Model Offerings and Limitations

iamcapote · 22 Mayo, 2025 17:53

AI Features Offered: Models, Constructs & Limits

Choosing the Right BIThub AI Surface

BIThub AI is not just a model picker.

It is a structured AI workspace where users choose a model, choose a Construct, and route work through the right AI surface.

A model is the inference engine.

A Construct is the reasoning frame, behavior layer, tool profile, and task identity wrapped around that model.

The best result usually comes from the right model + Construct pair.

Current Status

BIThub is in closed alpha.

Models, Constructs, tools, quotas, and access rules may change quickly.

We keep the roster lean on purpose: quality over quantity.

The goal is not to list every possible model.

The goal is to keep a good working roster for real BIThub workflows.

1. What BIThub AI Offers

BIThub AI has several working surfaces.

Each AI feature exists for a different kind of work.

AI Feature	What it is	Use it when
Private Messages	Direct chat with a Construct	You want the normal assistant-style workflow
Constructs	AI identities with defined reasoning behavior	You want the answer shaped by a specific cognitive frame
Models	Underlying LLM engines	You want to choose speed, context, cost, or capability
Nodes	Focused task terminals	You want a narrow workflow instead of open chat
COREs	Multi-stage workflow engines	You want one prompt to become a staged process
Workspaces	App-like tool surfaces	You want a focused interface for a specific tool or workflow
Tools	Extra capabilities available to some Constructs	You want search, calculation, web calls, diagrams, crypto data, or other callable functions

Private messages are the basic path.

Start there unless you already know you need a Node, CORE, Workspace, or external agent integration.

1.1 BIThub as a Workspace

This chart shows the main parts of the BIThub AI workbench: models, Constructs, tools, surfaces, and limits.

flowchart TD
    A{{BIThub AI Workbench}}:::hub
    A --> B[(Models / engines)]:::models
    A --> C[[Constructs /<br/>reasoning frames]]:::constructs
    A --> D((Tools /<br/>extra capabilities)):::tools
    A --> E[/Surfaces /<br/>places to work/]:::surfaces
    A --> F[\Limits /<br/>access boundaries/]:::limits

    linkStyle 0 stroke:#22d3ee,stroke-width:4px
    linkStyle 1 stroke:#a855f7,stroke-width:4px
    linkStyle 2 stroke:#34d399,stroke-width:4px
    linkStyle 3 stroke:#fbbf24,stroke-width:4px
    linkStyle 4 stroke:#f43f5e,stroke-width:4px

    classDef hub fill:#0f172a,stroke:#38bdf8,stroke-width:5px,color:#f0f9ff,font-size:17px
    classDef models fill:#083344,stroke:#22d3ee,stroke-width:3px,color:#ecfeff
    classDef constructs fill:#2e1065,stroke:#a855f7,stroke-width:3px,color:#faf5ff
    classDef tools fill:#022c22,stroke:#34d399,stroke-width:3px,color:#f0fdf4
    classDef surfaces fill:#451a03,stroke:#fbbf24,stroke-width:3px,color:#fffbeb
    classDef limits fill:#4c0519,stroke:#f43f5e,stroke-width:3px,color:#fff1f2

2. The Core Choice: Model + Construct

BIThub separates the model from the Construct.

That matters.

A strong model with the wrong Construct can still give the wrong style of answer.

A weaker model with the correct Construct can still give the wrong style of answer.

The model decides the raw inference engine.

The Construct decides the operating frame.

Use both deliberately.

Model = engine
Construct = behavior + task frame + tools + routing style
Output = model × construct × prompt × context

2.1 Traditional AI vs BIThub AI

This chart shows why BIThub is not just a model selector: the work mode and Construct shape the output before the model result becomes useful work.

flowchart TD
    subgraph Traditional ["🖥️ Traditional AI"]
        direction LR
        A[[Normal AI App]] --> B{Pick a Model}
        B --> C((Chat))
    end

    subgraph Modern ["⚡ BIThub AI"]
        direction LR
        D{{BIThub AI}} --> E{Pick a Work Mode}
        E --> F[Apply a Construct]
        F --> G{Use the Right Model}
        G --> H((Reusable Work Output))
    end

    Traditional ~~~ Modern

    classDef legacy fill:#c0392b,stroke:#922b21,stroke-width:3px,color:#fff
    classDef modern fill:#2980b9,stroke:#1f618d,stroke-width:3px,color:#fff
    classDef select fill:#f39c12,stroke:#d35400,stroke-width:2px,color:#fff
    classDef action fill:#8e44ad,stroke:#6c3483,stroke-width:2px,color:#fff
    classDef end1 fill:#e74c3c,stroke:#c0392b,stroke-width:2px,color:#fff
    classDef end2 fill:#27ae60,stroke:#1e8449,stroke-width:3px,color:#fff

    class A legacy
    class D modern
    class B,E,G select
    class F action
    class C end1
    class H end2

2.2 Raw Pipeline vs Constructed Pipeline

This chart shows the difference between a raw model answer and a task-shaped answer produced through a model + Construct pair.

flowchart TD
    subgraph Raw ["🔥 Unstructured Pipeline"]
        direction LR
        A[/Raw Model/]:::rawNode --> B[[General Intelligence]]:::rawNode
        B --> C{{Unshaped Answer}}:::rawEnd
    end

    subgraph Framed ["🎯 Constructed Pipeline"]
        direction LR
        D[/Model + Construct/]:::frameNode --> E[[Framed Intelligence]]:::frameNode
        E --> F{{Task-Shaped Answer}}:::frameEnd
    end

    Raw ~~~ Framed

    classDef rawNode fill:#e74c3c,stroke:#922b21,stroke-width:3px,color:#fff
    classDef rawEnd fill:#f39c12,stroke:#d35400,stroke-width:2px,color:#fff,stroke-dasharray: 5 5
    classDef frameNode fill:#3498db,stroke:#1f618d,stroke-width:3px,color:#fff
    classDef frameEnd fill:#2ecc71,stroke:#1e8449,stroke-width:3px,color:#fff
    classDef container fill:#1a1a2e,stroke:#16213e,stroke-width:2px,color:#eee

2.3 Output Quality

Output quality is affected by Model, Construct, Prompt, Context, Tools, and Limits.

flowchart TD
   A[[⚡ Output Quality]]:::hub
   A --> B[(🧠 Model)]:::f1
   A --> C[/🏗️ Construct/]:::f2
   A --> D>✍️ Prompt]:::f3
   A --> E[(🌍 Context)]:::f4
   A --> F{{🛠️ Tools}}:::f5
   A --> G[\🚦 Limits/]:::f6

   linkStyle 0 stroke:#3498db,stroke-width:3px
   linkStyle 1 stroke:#9b59b6,stroke-width:3px
   linkStyle 2 stroke:#e67e22,stroke-width:3px
   linkStyle 3 stroke:#1abc9c,stroke-width:3px
   linkStyle 4 stroke:#2ecc71,stroke-width:3px
   linkStyle 5 stroke:#e74c3c,stroke-width:3px

   classDef hub fill:#1a1a2e,stroke:#4a69bd,stroke-width:4px,color:#f5f6fa,font-size:17px
   classDef f1 fill:#3498db,stroke:#2980b9,stroke-width:2px,color:#fff
   classDef f2 fill:#9b59b6,stroke:#8e44ad,stroke-width:2px,color:#fff
   classDef f3 fill:#e67e22,stroke:#d35400,stroke-width:2px,color:#fff
   classDef f4 fill:#1abc9c,stroke:#16a085,stroke-width:2px,color:#fff
   classDef f5 fill:#2ecc71,stroke:#27ae60,stroke-width:2px,color:#fff
   classDef f6 fill:#e74c3c,stroke:#c0392b,stroke-width:2px,color:#fff

3. If You Do Not Know What to Pick

Use one of these two defaults.

3.1 Use `0.Null`

Use 0.Null when you want the model with minimal extra shaping.

0.Null is the baseline Construct.

It has no heavy system prompt.

Use it when you want to observe raw model behavior, compare models, test prompts, or avoid extra BIThub personality shaping.

3.2 Use `Router.CORE`

Use Router.CORE when you do not know which Construct fits the task.

Router.CORE is the dispatch Construct.

It helps select the best Construct for a query or task.

Use it when the task is ambiguous, multi-domain, or you are still learning the roster.

Router.CORE recommends the best-fit Construct or routing path for the task.

You still need to activate the recommended agents manually.

4. Current Model Roster

The model roster changes constantly.

Check the live model index for the current list:

All LLMs Available

5. Model Types

BIThub model labels are practical routing labels.

They are not status symbols.

5.1 Free

Free models are for testing, public experiments, lightweight access, and low-cost exploration.

Use them when the task does not need member-grade inference.

5.2 Small

Small models are compact models with enough capability for many normal tasks.

Use them for simple drafting, summarizing, formatting, extraction, classification, and quick iteration.

5.3 Fast

Fast models are not bad models.

Fast models are useful when throughput matters.

Use them for agent swarms, plugin-connected agents, repeated calls, routing loops, quick drafts, fast private-message work, and automation-heavy workflows.

Fast models are especially useful when external agents connect to BIThub through MCPs or BIThub AI Tools and need low-latency responses.

5.4 Large

Large models are the high-capability tier.

Use them when the task benefits from stronger reasoning, longer synthesis, complex document work, multi-step planning, code review, or high-stakes refinement.

Large does not automatically mean better for every task.

A large model with the wrong Construct can still produce the wrong output.

5.5 Premium

Premium models are the strongest available model tier.

Use them for final review, advanced synthesis, difficult reasoning, long-context work, publication-grade refinement, and high-value outputs.

Premium access may depend on membership tier, role, quota, cost, provider availability, or current alpha limits.

Premium models may change quickly when better models become available.

6. Construct Types

Constructs are BIThub’s vocabulary for agentic knowledge work.

The vocabulary matters because it gives users stable names for repeatable behavior.

Every term should earn its place through definition, repeated use, and visible behavior.

A Construct should tell the user:

what kind of reasoning it performs
what work it is suited for
what tools it may use
what output style it tends to produce
when not to use it

Use the registry for the full list:

BIThub Full List of CORE Constructs, Characters & Personas

7. Practical Pairing Patterns

Do not choose only by model strength.

Choose by workflow.

Workflow Pattern	Construct Choice	Model Choice
Raw model testing	`0.Null`	Any model you want to compare
Unsure what to use	`Router.CORE`	Fast or Large
Fast agent swarm	Runtime-specific Construct or `0.Null`	Fast
Forum navigation	Pathfinder-style Construct	Fast or Large
Crypto/on-chain work	Satoshi-style Construct	Fast or Large depending on depth
Compression / cleanup	Null Absolute-style Construct	Small or Fast
System synthesis	BITcore-style Construct	Large
Taxonomy / registry work	Metacore-style Construct	Fast or Large
Style mutation / prompt stress	B451LÍ5K05-style Construct	Fast
General assistant work	General Construct	Small, Fast, or Large
Best available model	Correct Construct for the task	Premium
Final review	Reviewer / synthesis Construct	Premium

This table is not a rulebook.

It is a routing map.

The right choice depends on the job, the context, and the output you want.

8. Main User Path

For most users, the path is simple.

1. Open AI chat.
2. Pick a Construct.
3. Pick a model.
4. Send a private message.
5. Review the output.
6. Change the model or Construct if the output shape is wrong.

This chart shows the basic BIThub AI route from task to output.

%%{init: {"theme": "base", "themeVariables": {"background": "#0b1020", "primaryColor": "#1e293b", "primaryTextColor": "#f8fafc", "primaryBorderColor": "#475569", "lineColor": "#334155", "secondaryColor": "#111827", "tertiaryColor": "#0f172a", "fontFamily": "Inter, ui-sans-serif, system-ui"}}}%%
flowchart TD
    A([User Task]) --> B{Choose AI Surface}

    subgraph Surfaces ["AI Surfaces"]
        direction LR
        C["Private Message<br/>bread and butter"]
        D["Node<br/>terminal workflow"]
        E["CORE<br/>multi-stage engine"]
        F["Workspace<br/>tool interface"]
    end

    B --> C
    B --> D
    B --> E
    B --> F

    C --> G{Choose Construct}
    D --> G
    E --> G
    F --> G

    subgraph Constructs ["Constructs"]
        direction TB
        H["0.Null<br/>raw baseline"]
        I["Router.CORE<br/>auto-dispatch"]
        J["Specialized<br/>task-shaped frame"]
    end

    G --> H
    G --> I
    G --> J

    H --> K{Choose Model}
    I --> K
    J --> K

    subgraph Models ["Model Tiers"]
        direction TB
        L["Free<br/>lightweight access"]
        M["Small<br/>compact tasks"]
        N["Fast<br/>throughput priority"]
        O["Large<br/>complex reasoning"]
        P["Premium<br/>maximum capability"]
    end

    K --> L
    K --> M
    K --> N
    K --> O
    K --> P

    L --> Q[[Model + Construct Pair]]
    M --> Q
    N --> Q
    O --> Q
    P --> Q

    Q --> R([BIThub AI Output])

    classDef default fill:#1e293b,stroke:#475569,color:#f8fafc
    classDef surface fill:#334155,stroke:#94a3b8,color:#f1f5f9
    classDef construct fill:#1e293b,stroke:#60a5fa,color:#e0f2fe
    classDef model fill:#172554,stroke:#818cf8,color:#e0e7ff
    classDef decision fill:#0f172a,stroke:#f59e0b,color:#fffbeb,stroke-width:2px
    classDef pair fill:#111827,stroke:#10b981,color:#d1fae5,stroke-width:3px
    classDef endpoint fill:#064e3b,stroke:#34d399,color:#ecfdf5,stroke-width:2px

    class A,R endpoint
    class B,G,K decision
    class C,D,E,F surface
    class H,I,J construct
    class L,M,N,O,P model
    class Q pair

Private messages are the bread and butter. This is the path most similar to ChatGPT-style usage.

Read:

Getting Started with BIThub AI

9. Model Changes and Deprecations

Models can be added, removed, renamed, or replaced quickly.

BIThub can move faster than upstream providers because the platform is still in active development.

A model may be removed or replaced when:

a better model becomes available
the provider removes or changes the model
the model becomes unreliable
the model is too expensive for its value
the model is redundant
the model does not fit BIThub workflows
the roster needs to stay clean

BIThub’s model policy is simple:

Keep the roster useful.
Prefer quality over quantity.
Remove weak or redundant models.
Add better models when they improve the system.
Tell users when a change affects usage.

Deprecations are not failure.

They are roster maintenance.

If a model disappears, check the live index: