AI Orchestrator
A personal AI workspace connecting scoped specialists, source-linked memory, Python checks and human decisions.
What it does
Follow the brief through the system. The return route shows a revision.
-
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.
-
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.
-
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.
-
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.
-
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.
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
Source
Reference, version, source date
Current claim
Reviewed and eligible
Recall
Exact fields or lexical search
History
Earlier versions retained
A confirmed correction replaces the current claim.
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:
- 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.
- Check scope, source support and conflicts before accepting a candidate. Uncertain or sensitive material needs its own review.
- 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.
- 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.
- Today
- 100.0%
- Day 7
- 69.8%
- Day 30
- 21.5%
- Day 60
- 4.6%
JEV judgements
Called on demand
State
Permitted facts + a narrow question
JEV
Choice / Score / Noul
Advisory output
Option, rating or probability of yes
Decision
Code and owner retain control
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.