iOS · iPadOS · macOS auto-hébergé zéro télémétrie

Junction

L'interface entre l'intelligence et tes machines.

Un harnais agentique complet : la boucle LLM ⇄ tool calls ⇄ MCP tourne directement dans l'app et relie 14 providers à tes serveurs MCP distants. Le téléphone est le harnais — aucun companion desktop, aucun relais intermédiaire.

Capture d'écran de Junction — vue principale du chat agentique
projets hypermemory
0
outils MCP découverts
0
machines executoria
0
skills chargées
0
providers (11 API + 3 harnais)
0
plateformes
0
tests automatisés (suite JunctionCore)
0+

Ça bouge

Dernières livraisons

Junction avance vite. Les dernières capacités arrivées dans l'app — toutes fonctionnelles.

  1. livré

    Terminal machine + dossier de travail

    Commande, sortie, durée, historique — chaque commande est un aller-retour indépendant, le dossier de travail persistant par machine tient le rôle du cd.

  2. livré

    Fichiers machine

    Navigation dans les fichiers de tes machines executoria, directement depuis l'app.

  3. livré

    Tâches & planifications

    L'interface du cron hypermemory (schedule_create), avec l'UTC affiché explicitement — plus de fuseau ambigu.

  4. livré

    Siri & App Intents

    Demander à Junction, approuver une action, consulter le statut — Siri et l'app Raccourcis peuvent déclencher l'app.

  5. livré

    Raccourcis personnels à registre manuel

    L'agent déclenche uniquement les raccourcis que tu as inscrits toi-même, par nom exact. Aucune découverte, aucun matching approché.

  6. livré

    OCR on-device

    Le texte d'une photo ou d'un document scanné est extrait sur l'appareil — rien ne part au cloud.

  7. livré

    Conductor — noyau testé

    Le runtime de missions durables existe dans JunctionCore, couvert par 331 lignes de tests. L'interface arrive ensuite.

  8. livré

    Journal d'activité & streaming

    L'agent trace ce qu'il fait dans un journal consultable, et les réponses arrivent token par token.

Le tour du propriétaire

Explorer les vues

Six surfaces, une seule app. Clique sur un onglet pour voir ce que chaque vue sait faire.

  • Vraie boucle agentique : tool calls visibles en monospace, barre d'activité, bouton Arrêter.
  • 14 providers au même endroit : 11 API + 3 harnais distants.
  • Jusqu'à maxTurns = 12 outils enchaînés par question, réponses en Markdown.
  • Avis honnête « aucun modèle connecté » — zéro fausse réponse.
Vue Chat de Junction avec tool calls affichés

En vrai

Un tour de boucle agentique

Une question, deux tool calls, une approbation, une réponse. Voilà à quoi ressemble une session Junction — reconstituée fidèlement.

junction — session agentique

tool call list_projects()

54 projets · 12 actifs cette semaine

tool call machine_exec(host: "mac-atelier", cmd: "cargo build --release") approbation demandée

↳ ApprovalSheet affichée · autorisé (famille « builds », 30 min)

exit 0 · Finished `release` profile in 1m 42s

agent 54 projets en mémoire, 12 actifs. Le build release d'hypermemory vient de passer sans erreur sur mac-atelier — binaire prêt dans target/release/.

Chaque machine_exec demande ton accord. Refus par défaut : rien ne part sans toi.

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 10 machines, exécutée sous approbation.

Transport Streamable HTTP en HTTPSaucun 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.
  • Streaming token par token : la réponse s'écrit sous tes yeux, sans attendre la fin du tour.
  • 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.
Terminal machine de Junction — commande, sortie et durée

Terminal machine

Un terminal sur chaque machine de la flotte : tu tapes la commande, Junction affiche la sortie, la durée et conserve l'historique.

  • Chaque commande est un aller-retour indépendant — pas d'émulateur, pas de session shell persistante.
  • Le dossier de travail tient le rôle du cd : persisté par machine, avec les derniers dossiers visités.
  • Réglage humain uniquement : le dossier de travail n'est pas exposé au modèle.
  • Pas d'écran d'approbation quand c'est toi qui tapes — l'approbation vise l'agent.

Fichiers machine

Navigue dans l'arborescence de tes machines executoria depuis l'app : dossiers, fichiers, contenus — sans ouvrir de session SSH.

Tâches et planifications de Junction — cron hypermemory

Tâches & planifications

L'interface du cron hypermemory : crée et suis les planifications (schedule_create) depuis la poche.

  • UTC explicite : l'heure affichée ne dépend pas du fuseau du moment.
  • Notifications locales pour les tâches longues — tu sais quand c'est fini, sans rester devant.
Siri, App Intents et raccourcis personnels dans Junction

Siri, App Intents & Raccourcis

Junction s'intègre à iOS : Siri et l'app Raccourcis peuvent déclencher l'app via des App Intents dédiés.

  • Intents implémentés : demander à Junction, approuver une action, consulter le statut.
  • Raccourcis personnels : l'agent ne déclenche que les raccourcis inscrits à la main dans le registre, par nom exact.
  • Aucune découverte, aucun matching approché — l'outil n'est même pas monté si la liste est vide.
OCR on-device de Junction — texte extrait d'une photo

OCR on-device & device tools

Le texte d'une photo ou d'un document scanné est extrait sur l'appareil — rien ne part au cloud.

  • Sélecteur de photos et scanner de documents intégrés.
  • Manifeste des capacités : l'app déclare honnêtement ce que l'appareil sait faire, et l'agent s'y tient.

Journal d'activité

L'agent trace ce qu'il fait : chaque action est consignée dans un journal consultable. Tu sais toujours ce qui s'est passé, et quand.

Conductor noyau livré

Le runtime de missions durables existe dans JunctionCore, couvert par 331 lignes de tests. L'interface utilisateur arrive dans une prochaine livraison.

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.

Grants 30 min bornés par politique

Les autorisations par famille d'actions expirent après 30 minutes — et les profils privilégiés user_full / system_admin ne sont jamais couverts par une autorisation de famille : chaque action sensible demande son propre accord.

Raccourcis à registre manuel

L'agent ne déclenche que les raccourcis que tu as inscrits toi-même, par nom exact. Pas de découverte automatique, pas de matching approché — et l'outil n'existe pas tant que la liste est vide.

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

Les Réglages couvrent aussi le dossier de travail par machine (utilisé par le terminal, jamais exposé au modèle) et le registre de raccourcis personnels que l'agent est autorisé à déclencher.

Demain

Roadmap

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

livré Récemment arrivé

  • Écriture hypermemory sous approbation
  • Autorisation par famille d'actions (30 min)
  • Mémoire locale du téléphone
  • Prompt système vivant alimenté par l'état réel
  • Canaux lus et écrits depuis l'iPhone
  • Cache hors-ligne des 54 projets
  • 87 skills → 8 injectées par pertinence
  • Les 3 harnais distants répondent
  • Terminal machine — commande, sortie, historique, dossier de travail persistant par machine
  • Fichiers machine — navigation dans l'arborescence des machines executoria
  • Tâches et planifications — interface du cron hypermemory (schedule_create), UTC explicite
  • Streaming token-par-token des réponses
  • Notifications locales pour les tâches longues
  • Raccourcis déclenchables par l'agent — registre manuel, noms exacts, aucune découverte
  • Siri & App Intents — demander à Junction, approuver, statut
  • OCR on-device — le texte d'une photo ou d'un document extrait sur l'appareil
  • Device tools — manifeste des capacités de l'appareil
  • Journal d'activité — l'agent trace ce qu'il fait

en cours En développement

  • Conductor — missions durables : noyau livré et testé (331 lignes de tests), interface à venir

prochain Prochainement

  • Interface du Conductor (missions durables)
  • Notifications push

exploration À étudier

  • L'iPhone comme nœud executoria — à étudier
  • Workflows multi-machines — à étudier
  • JavaScriptCore glue — à étudier
  • Foundation Models on-device — à étudier
  • Watch : approbation au poignet — à étudier

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.