iOS · iPadOS · macOS

Junction

L'interface entre l'intelligence et tes machines.

Junction est un harnais agentique : une boucle LLM ⇄ tool calls ⇄ MCP tourne directement dans l'app et relie les API des grands modèles à tes serveurs MCP distants. Le téléphone est le harnais — aucun companion desktop, aucun relais intermédiaire.

Fonctionnalités Comment ça marche
Capture d'écran de Junction — vue principale du chat agentique

Architecture

Comment ça marche

Trois pièces, une boucle. Junction se place au centre et fait circuler les tool calls entre les modèles et tes serveurs MCP.

LLM

11 providers API + 3 harnais distants

OpenRouter, Anthropic, OpenAI, Kimi, Moonshot, Z.ai, Zhipu, DeepSeek, Groq, Mistral… ou tes propres CLI (Claude Code, Codex, Kimi Code) pilotées sur ta machine.

Junction

La boucle agentique vit dans l'app

Tool calls exécutés localement, approbations humaines avant chaque action sensible, mémoire et contexte injectés avant chaque tour. Pas de serveur intermédiaire.

MCP distants

hypermemory · executoria

hypermemory : mémoire, 54 projets, canaux de coordination. executoria : ta flotte de machines, exécutée sous approbation.

Transport Streamable HTTP en HTTPS — aucun port entrant sur tes machines ni sur ton téléphone.

Capacités

Fonctionnalités

Chaque fonctionnalité listée ici est implémentée et fonctionnelle. Rien n'est une promesse.

Chat agentique de Junction avec tool calls affichés

Chat agentique

Une vraie boucle agentique, pas un simple chat : le modèle appelle des outils, Junction les exécute et renvoie les résultats, jusqu'à maxTurns = 12.

  • 11 providers API : OpenRouter, Anthropic, OpenAI, Kimi For Coding, Moonshot, Z.ai/GLM (×2), Zhipu, DeepSeek, Groq, Mistral, custom.
  • 3 harnais distants pilotés via executoria : Claude Code, Codex CLI, Kimi Code — tes abonnements, tes CLI, ta machine.
  • Tool calls affichés en monospace, barre d'activité et bouton Arrêter.
  • Conversations persistées, sélection multi-machines, réponses rendues en Markdown.
  • Avis honnête « aucun modèle connecté » — zéro fausse réponse.
Vue mémoire de Junction — projets hypermemory

Mémoire — hypermemory

54 projets réels accessibles depuis la poche, avec cache disque : tes données s'affichent même hors-ligne.

  • Viewer Markdown à 3 modes : Aperçu, Source numéroté, Éditer brouillon.
  • Troncature annoncée quand un contenu est coupé — jamais masquée.
  • Recherche locale instantanée dans les projets et les mémoires.
Flotte de machines executoria dans Junction

Machines — executoria

Ta flotte réelle : seules les machines joignables sont listées, avec une fiche détaillée pour chacune.

  • Outils agent : machine_list, machine_exec (sous approbation), machine_read_file, machine_glob, machine_grep.
  • Suivi des calls avec idempotence — un call relancé ne s'exécute pas deux fois.
  • Jamais de faux succès : une machine injoignable est affichée comme telle.
Canaux de coordination hypermemory dans Junction

Canaux

Lis et écris sur les canaux de coordination hypermemory depuis l'iPhone — la coordination humain ⇄ agent ne quitte plus ta poche.

  • Identités junction-iphone / junction-mac stockées au Trousseau.
  • Messages longs repliables, humains distingués visuellement des agents.
Compétences chargées depuis hypermemory dans Junction

Skills

87 compétences chargées depuis hypermemory — projet partagé + projet courant — qui étendent l'agent sans toucher au code.

  • Les 8 plus pertinentes sont sélectionnées et injectées au prompt système.
  • L'outil skill_read charge n'importe quelle compétence à la demande.
  • Ajouter une compétence = déposer un fichier Markdown. Pas de recompilation.

Prompt système vivant

Avant chaque tour, l'agent sait déjà quelles machines sont joignables, quels services répondent et quelles sont ses limites du moment. Il ne devine pas : il constate.

  • « Ce que je sais faire » (HelpView) présente exactement la même vérité à l'humain.
  • Capacités absentes grisées avec leur raison — jamais cachées, jamais simulées.

Presse-papier partagé

Envoie et récupère des extraits entre tes appareils via hypermemory. Un pont simple entre iPhone, iPad et Mac, sans service tiers.

CLI junction-cli

Le même moteur, en ligne de commande : spike MCP + sous-commande agent, construite sur les mêmes modules que l'app.

  • Whitelist d'outils identique à celle de l'app.
  • Jetons fournis par variable d'environnement — rien d'écrit en dur.

Confiance

Sécurité

L'agent peut beaucoup. Chaque pouvoir est borné, visible et révocable.

Clés au Trousseau

Jetons et clés API stockés dans le Trousseau avec ThisDeviceOnly. Jamais réaffichés après saisie, jamais synchronisés.

HTTPS obligatoire

Aucun transport en clair. Toutes les connexions MCP passent en HTTPS, point.

Approbation pour machine_exec

Chaque exécution à distance affiche une ApprovalSheet avec la commande exacte. Refus par défaut : rien ne part sans ton accord explicite.

Whitelist stricte

34 outils hypermemory en lecture, pas un de plus. Tout outil non listé est invisible pour le modèle et rejeté côté client.

Jamais de fausse donnée

Fixtures supprimées. Chaque état est honnête : live, périmé ou erreur — affiché tel quel.

Aucune télémétrie

Pas de tracking, pas d'analytics, pas de SDK tiers. Tes usages restent chez toi.

Démarrage

Comment l'utiliser

Quatre étapes, quelques minutes.

  1. 1

    Connecter hypermemory

    Réglages → ajoute ton serveur hypermemory (URL …/mcp + jeton). Le test de connexion est franc : ça passe ou ça dit pourquoi.

  2. 2

    Connecter executoria

    Ajoute l'URL du hub + jeton. Une sonde /health vérifie que la flotte répond.

  3. 3

    Choisir un provider LLM

    Catalogue intégré : sélectionne un provider, colle ta clé API — elle part au Trousseau. Ou choisis un harnais distant pour utiliser tes abonnements existants.

  4. 4

    Discuter

    C'est tout. L'agent connaît déjà tes projets, tes mémoires et tes machines avant le premier message.

Écran Réglages de Junction — connexions hypermemory et executoria

Demain

Roadmap

Ce qui est en cours — présenté comme tel, sans date promise.

  • en cours Écriture hypermemory sous approbation
  • à venir Terminal et fichiers machine
  • à venir Streaming token-par-token
  • à venir Device tools : caméra, Siri / App Intents, Raccourcis
  • à venir Notifications push
  • à venir Conductor — missions durables

Questions

FAQ

Mes données partent où ?

Uniquement vers tes serveurs : les API LLM que tu as choisies, hypermemory et executoria — que tu héberges. Aucune télémétrie, aucun tiers, aucun relais. Les clés restent au Trousseau, sur l'appareil.

Faut-il un Mac allumé ?

Non pour le chat avec les providers API : tout part de l'app vers Internet. Oui si tu utilises les harnais distants (Claude Code, Codex CLI, Kimi Code) ou les outils machines — ils tournent sur ta machine, par définition.

Quels modèles ?

Tout ce que proposent les 11 providers supportés : OpenRouter (des centaines de modèles), Anthropic, OpenAI, Kimi For Coding, Moonshot, Z.ai/GLM, Zhipu, DeepSeek, Groq, Mistral, ou un endpoint custom. Plus tes propres CLI via les harnais distants.

C'est quoi, une skill ?

Un fichier Markdown qui enseigne une compétence à l'agent (une procédure, un contexte, un savoir-faire). Junction en charge 87 depuis hypermemory, en injecte les 8 plus pertinentes au prompt, et lit les autres à la demande. En ajouter une = déposer un fichier.

C'est open source ?

Non. Junction est un projet personnel, distribué tel quel. L'infrastructure qu'il pilote (hypermemory, executoria) est auto-hébergée — c'est elle qui te garantit l'indépendance.

Et TestFlight ?

La distribution se fait via TestFlight, sur invitation. Si tu es sur la liste, installe, configure tes deux serveurs, choisis un provider — et discute.