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.

Démarrer Fonctionnalités Roadmap
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

Aller droit au but

Raccourcis

Guide de démarrage

Deux serveurs, une clé API, quatre étapes — et tu discutes.

Sécurité & approbations

Chaque pouvoir est borné, visible et révocable.

Les skills

87 compétences en Markdown, 8 injectées par pertinence.

CLI junction-cli

Le même moteur que l'app, en ligne de commande.

FAQ

Données, modèles, TestFlight : les réponses franches.

Roadmap

Livré, en cours, prochain, exploration — sans date promise.

Ça bouge

Dernières livraisons

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

  1. livré

    Écriture hypermemory sous approbation

    L'agent écrit dans la mémoire partagée, avec ton accord explicite à chaque fois.

  2. livré

    Autorisation par famille d'actions (30 min)

    « Autoriser les écritures » ≠ « autoriser les commandes ». Jamais de chèque en blanc.

  3. livré

    Mémoire locale du téléphone

    L'agent se souvient d'une session à l'autre, même sans serveur.

  4. livré

    Prompt système vivant

    Avant chaque tour, l'agent connaît l'état réel : machines joignables, services, limites du moment.

  5. livré

    Canaux lus et écrits depuis l'iPhone

    La coordination humain ⇄ agent ne quitte plus ta poche, sous l'identité junction-iphone.

  6. livré

    Cache hors-ligne

    Tes 54 projets consultables sans réseau, avec l'état « périmé » affiché honnêtement.

  7. livré

    87 skills → 8 injectées par pertinence

    La bonne compétence au bon moment, choisie automatiquement parmi 87.

  8. livré

    Les 3 harnais distants répondent

    Claude Code, Codex CLI et Kimi Code pilotés sur ta machine — tes abonnements, tes CLI.

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 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 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
  • Tâches et planifications — interface du cron hypermemory (schedule_create)
  • 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

en cours En développement

  • Caméra, photos et OCR local (sélecteur photothèque)
  • Conductor — missions durables (noyau)

prochain Prochainement

  • Device tools : caméra, photos et OCR local
  • App Intents, Siri et Raccourcis
  • Notifications push

exploration À étudier

  • Device tools : caméra, Siri / App Intents, Raccourcis — à étudier
  • L'iPhone comme nœud executoria — à étudier
  • Workflows multi-machines — à étudier
  • Conductor — missions durables — à é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.