Software

AI Orchestrator

A personal AI workspace connecting scoped specialists, source-linked memory, Python checks and human decisions.

Public overview · private implementation

What it does

  1. 01 Define the outcome Human direction
    Input
    A request, a real constraint and a desired result.
    Output
    A bounded brief with a checkable finish.

    This websiteExpand this portfolio's AI projects while keeping the existing brand and private sources separate.

    I decide the objective and what the system may change.

  2. 02 Bound the context Coordinator
    Input
    The brief and the sources permitted for this task.
    Output
    A small assignment for the right specialist.

    This websiteUse the public project copy, approved visual system and existing Astro code.

    A relevant source does not grant permission to share it.

  3. 03 Do the work Scoped specialist
    Input
    The assignment, relevant evidence and allowed tools.
    Output
    A draft, analysis or implementation for checking.

    This websiteAI agents produce the project text, Astro components and calculated graph on this page.

    A specialist's recommendation is advice, not approval.

  4. 04 Check the result Code and review
    Input
    The result and the task's acceptance conditions.
    Output
    Evidence of what passed, failed or remains unknown.

    This websiteThe production build and automated browser checks pass. Visual review remains a separate check.

    A successful command does not prove the whole task worked.

  5. 05 Decide what ships Human review
    Input
    The checked result, its limitations and proposed action.
    Output
    Accept, revise or hold at the relevant release boundary.

    This websiteKeep the update local for my visual review before publishing it.

    Checks do not replace creative judgement or release permission.

Conceptual workflow, not a live execution trace. Open a stage to inspect the hand-off.

Scope, tools and approval boundaries

Scope

A hub-and-spoke router sends bounded work to specialist agents without giving one specialist access to another specialist’s private context

Repeatable checks

Python routines handle repeatable checks, validation, scheduling, duplicate detection and state comparisons before model judgement is used

Model choice

Model choice considers the task, the approved connection and available capacity; a failed route does not grant permission to switch providers or start spending

Human authority

Human approval remains a separate requirement for consequential actions, even when an agent recommends them or a technical check passes

  • Persistent context is separated by project and specialist rather than merged into one global memory
  • Recorded requests and replies show where an assignment went and what came back
  • Knowledge maps connect project records and reviewed methods to their original sources
  • Scheduled jobs handle bounded monitoring and preparation; the system reports exceptions rather than generating activity for its own sake
  • Chat interfaces provide direct access to the assistant and scoped specialists
  • MCP integrations connect supported tools; every connection retains its own access and action limits

Multi-agent setup

Coordinator

Scope, route, check

Systems

Own skills and context

Creative

Own skills and context

Finance

Own skills and context

Assignments out. Evidence back.

Separate profiles. One coordinator connects the work through a Python router and recorded request/reply hand-offs.

Private contexts stay separate. I keep approval and release authority.

Inside a hand-off

I use a coordinator and specialist agents for different kinds of work, including systems, creative review and personal finance. They run in separate Hermes profiles, with their own instructions, skills and authorised context. I can speak to a specialist directly; delegated work returns through the coordinator.

The backend uses a Python router and a SQLite exchange ledger. A hand-off carries a bounded question, permitted evidence and a clear action limit. The recorded request and reply let me check who received it and what came back. Specialists do not pass private work directly between themselves.

For this website, a creative specialist can advise on the composition while a systems specialist checks the simplest implementation. The coordinator combines independently permitted advice, implements within the agreed scope and runs the checks. I judge the visible result and decide whether to publish it.

Shared methods contain only information cleared for their readers. Each specialist’s private memory stays separate. A request to review a draft does not grant permission to edit a live system, spend money or publish it.

Agent memory

  1. Source

    Reference, version, source date

  2. Current claim

    Reviewed and eligible

  3. Recall

    Exact fields or lexical search

History

Earlier versions retained

A confirmed correction replaces the current claim.

Local SQLite stores source-linked claims. A bounded selection reaches the answer; fading changes its ranking.

Automatic intake remains off. Wider source coverage and other-agent rollout are unfinished.

Storage, corrections and coverage

A useful assistant needs to remember a decision, recognise a correction and stop treating an old statement as the current answer. My memory work separates the original source, the current claims derived from it and the small amount of context supplied to one answer.

The working prototype uses local SQLite storage and a private recall connection in the coordinator’s personal profile. Its lifecycle is:

  1. Keep the source reference, source version and original source date with each admitted claim. A generated summary is not a replacement for the original evidence.
  2. Check scope, source support and conflicts before accepting a candidate. Uncertain or sensitive material needs its own review.
  3. Retrieve eligible current claims using exact fields or lexical search, which matches words rather than semantic similarity. Only a bounded selection reaches the answering model.
  4. Link a confirmed correction to the claim it replaces. Current recall excludes the predecessor; explicit history can recover the earlier version.

Ordinary context loses ranking weight with age, alongside its reviewed usefulness. Looking it up does not make the source newer. Protected instructions and unfinished commitments follow separate rules. Fading reduces prominence; it does not erase the source or declare an older statement false.

The goal is coverage across chats, documents, email and project files, with relevance managed at retrieval. Deliberate admissions and source indexing work now. Automatic content intake and broader source coverage are still in development. The automatic path has passed isolated checks but remains off pending qualification in the running app and registered source collection. This memory adapter is not rolled out to every specialist.

The graph below isolates one part of that behaviour. Moving the age control changes a calculated relevance weight. It does not simulate a model, read private memories or measure whether an answer is correct.

Relevance over time

Ordinary context can fade. Protected rules keep their place.

Context weight

69.8%

At day 7

Illustrative ranking weight, not accuracy. The source stays available.

Ordinary contextProtected rules: no age decay
TodayAge of context60 days
Today
100.0%
Day 7
69.8%
Day 30
21.5%
Day 60
4.6%
Calculated illustration using the current context-decay setting, 0.95 per day. Protected instructions and unfinished commitments use separate eligibility rules.

JEV judgements

Called on demand

  1. State

    Permitted facts + a narrow question

  2. JEV

    Choice / Score / Noul

  3. Advisory output

    Option, rating or probability of yes

  4. Decision

    Code and owner retain control

TypeSafe's evaluator supports bounded judgements and route recommendations. Uncertain results stay with the coordinator.

Private histories stay out. Advice grants no permission and proves no performance gain.

Questions, routing and limits

JEV, TypeSafe’s model for narrow judgements, sits beside the agents as an on-demand evaluator. The integration accepts a small state and explicit questions, then returns structured answers:

  • Choice selects from named alternatives, such as a suitable permitted route.
  • Score rates supplied evidence against defined levels.
  • Noul returns the probability of yes for a specific question.

The workspace exposes a general evaluation tool and a separate routing adviser. The routing tool receives categories and flags instead of the original private request. It can recommend the coordinator or an allowed specialist; uncertain or failed responses leave the coordinator responsible.

These tools are advisory. Code handles source checks, calculations and fixed permission rules. I keep private histories, personal records and confidential work out of this integration. An evaluation does not grant action authority, replace a build or browser check, or establish that a claim is true.

The tools are available on demand, not an automatic judgement on every message. I am not claiming measured accuracy, time savings or lower costs for this setup.

Knowledge maps

Follow relationships back to the source instead of treating a graph as the answer.

Sources and access

A map helps me find the right evidence across projects and reusable methods. I can follow a relationship back to its current source and check where a claim came from.

The workspace includes an owner-only explorer and a separate map of reviewed methods. A visible node means that a record is represented in that view. It does not prove that an agent read it, that its claims are correct or that another specialist may access it. Source dates, corrections and reader boundaries remain part of the system.

This website

A real application of the workflow, from creative brief to code and browser checks.

AI-built, human-directed. Static public pages; no connection to my private workspace.

Build and authorship

AI-built, human-directed. This portfolio is itself an application of the workflow: I set the brief, choose the visual direction and review the work; AI agents develop drafts, code and checks. Project imagery and third-party tools retain their own authorship.

The implementation uses Astro to generate static pages. The Pressed Ink identity reuses one liquid field and authored stills. GSAP drives the existing field, while Python and Playwright support repeatable content, interaction and browser checks. The workflow diagrams use native HTML and SVG; they remain readable without JavaScript.

The public build contains project explanations and cleared assets, not a connection to my personal agent workspace. A build passing is technical evidence. I still decide whether the result is useful, looks right and is ready to publish.

Background

I work across physical systems, audio software and automation. I wanted a workspace where I could move between those projects without one general assistant trying to carry every detail. I am building a personal orchestration layer around Hermes Agent: separate specialists, scoped context, repeatable Python routines and a coordinator that keeps the work connected.

My contribution is the system around the models. I define the workflows, choose the boundaries, connect the tools and decide what evidence a result needs. AI agents help with research, drafts, implementation and review. Existing frameworks and model providers supply the underlying capabilities.

The toolchain

  • Hermes Agent by Nous Research supplies the agent runtime and separate profiles
  • Python handles orchestration, validation and repeatable operations
  • SQLite stores structured, source-linked records
  • MCP (Model Context Protocol) connects supported tools through explicit interfaces
  • Local and approved cloud models provide different kinds of judgement
  • Astro, GSAP and native browser features build the public portfolio experience
  • Playwright and automated checks exercise the resulting pages and controls

Limitations

This is a personal workspace, not a multi-user commercial product or a formally certified policy engine. Profile separation helps organise context; it is not an operating-system sandbox. Local memory storage also does not mean every model call runs locally: an approved cloud model may process the context supplied to it.

Source coverage, permissions, tools and model behaviour remain different concerns. A connected service does not prove complete ingestion, and a retrieved claim does not prove that the final answer used it correctly. Broader memory capture and source-to-answer usefulness remain active development work.

The repository stays private because the system operates real accounts and files. The public examples explain the workflow without exposing those connections. I publish no savings or performance figures for this system.