Less
Context per call, by design
Context engineering, sub-agent delegation, and disciplined session architecture cut the bulk of tokens most systems waste on re-reading history they don't need.
Open-weight models on hardware you own, an agent harness, retrieval over your own data, and guardrails that hold. Orchest AI is an architecture practice, not a vendor: I design it, prove it on your box, hand it over, and do not become a dependency.
The stack you end up owning · all open, all replaceable
A supervisor plans, sub-agents specialize, agentic RAG gives them memory. Every node is observable, every edge is governed. This is the blueprint I design for your business, on models you host, tuned to your data and your policies. The diagram is the proof: it shows where data can and cannot go.
Most AI systems burn money by feeding the model everything, every turn, through a metered API. The framework is engineered so the model only sees what it needs, and when it runs on your own hardware the bill stops scaling with usage. The honest numbers: a self-hosted model on an entry server pays for itself in months at moderate volume; below that, an API is cheaper and I will say so.
Context engineering, sub-agent delegation, and disciplined session architecture cut the bulk of tokens most systems waste on re-reading history they don't need.
Heavy research runs in a specialist's own context window and only the distilled answer comes back, so the main session never bloats.
Skills, prompts, and reference data are loaded on demand, not stuffed into every call. Fewer tokens in, more attention on the task.
Inputs are normalized before the model sees them, so dense source material arrives in a fraction of the original token weight.
Smaller models handle triage and summarization. Frontier models run only where reasoning depth actually moves the outcome.
Long-running work is chained across focused sessions with structured handoffs, never one runaway chat that spirals out of control.
Every run is logged with tokens, latency, and cost per agent, so you can see exactly where spend goes and where to tune.
You do not have to leave your API vendor on day one. Ownership of the stack has four parts: models, compute, harness, data. Every engagement moves one or more of them onto your side of the line, without a rebuild later.
The model can stay on a frontier API for now. The harness, the retrieval index, the audit log and the runbooks are yours from the first week, so switching the model later is a config change, not a migration.
For teams whose data cannot leave: healthcare, finance, legal, anyone under HIPAA, GLBA or a client confidentiality duty. Local serving, a governed agent harness, and evidence a second-line reviewer can read.
A vendor lists features. An architect lists what you keep. This is the list, and it goes into the scope document before any build starts.
Every line of code, in your GitHub or GitLab, under a licence that lets you keep running it after I am gone.
Open-weight models pulled to your hardware. No key of mine in the path. Swap the model with a config change.
A sizing spec you own outright: what to buy, what it costs, what it can and cannot run. Bought in your name.
The agent runtime, the loop definitions, the skills, the memory store. Plain files you can grep, back up and delete.
Your documents, embedded on your box, cited by source line in every answer. Rebuildable from your files alone.
Approval gates, spend caps and a tamper-evident log of every action. The evidence a reviewer asks for.
How to operate it, upgrade it, and roll it back. Your people run it without hiring an AI person.
What you keep if you end the engagement next month: everything above. Written into the scope before we start.
Opinionated defaults, all open, all replaceable. The limits are published with them: models under 14B do not hold an agent loop; 30B and above with 64K context is the real floor; below moderate volume an API is cheaper and I will say so.
OpenClaw-style local agent runtime, skills and memory as Markdown and YAML on disk
Ollama for a single box, vLLM when throughput matters
Qwen3.6 27B or GLM-4.7 class open weights, 64K context; a frontier API where reasoning depth moves the outcome
Chroma or Weaviate with nomic-embed, citations to the source line
Open WebUI, Slack or Teams, or your own UI
Approval gates, spend caps, role-based access, hash-chained audit log
The question operators ask now is not whether to use agents. It is what agentic adoption actually yields, and what to do when an agent is the wrong tool. Three shapes cover most real work. A pipeline: deterministic steps with a model inside one or two of them, easiest to audit. A loop: a recurring goal with memory that runs on a schedule and pauses at a guardrail. An agent: open-ended planning over tools, reserved for problems where the path genuinely cannot be written down. Start with the pipeline. Promote to a loop when the job recurs. Promote to an agent only with evidence. Harness engineering, the discipline around context, logging, delegation, compaction and gates, is what makes any of the three survive a real workflow.
Talk to your agents in plain English, inside Slack, Teams, or your own UI. They pull context, take action, and close the loop.
When an agent handles a workflow once, it's codified as a repeatable skill. The library grows with your business, and so does what the team can hand off.
onboarding-kickoff, authored from last Tuesday's walkthrough.
Agents execute multi-step work without supervision, but only within the policies you set. Spend limits, approval steps, and sensitive-action gates are built in.
No new tool to log into. Your agents live in Slack, Teams, and the inbox, pulling from your knowledge base so every answer is grounded in your docs.
Builds on Claude, on open weights, or on both. The harness decides what each step sees, what gets logged, how work is delegated to sub-agents, how long sessions are compacted and handed off, and where the spend caps and approval gates sit. It is the same discipline whether the model is local or remote.
Specialist agents hand work to each other. Long tasks run overnight. Nothing drops between teams.
The common work, email, CRM, calendar, docs, ticketing, already wired up and battle-tested.
Every correction teaches the system. Agents get sharper at your business every week they run.
A custom skill goes from demo to live in days, with the same rigor as your core platform.
Claude-powered planning across multi-step work, grounded in retrieval that reasons over your data.
Role-based access, spend caps, approval gates, and full action logs. Auditable from day one.
The shift this year isn't a better prompt, it's a different unit of work. One message gives you one output and waits on you. A loop is a recurring goal with memory: it remembers the context, watches for what changed, and acts on a schedule, all the way to the guardrail where it hands back to a human.
Every loop we ship runs on the same lifecycle, PAL, so it stays observable and reversible end to end.
Break the recurring goal into steps the loop can run on its own.
Act against your live tools, email, CRM, calendar, data.
Reconcile results into shared state and memory.
Re-arm on schedule, or stop at the guardrail for a human.
A working, white-label loop console, reskin it, define a loop, watch it persist.
12 years in enterprise data, a decade across banks, six years of it at MUFG, then Citi. Before that, onsite implementations of a governance, risk and compliance platform for regulated clients at Nasdaq BWise: install, configure, train, own the outcome. The systems I built lived under audit, which is where the habits come from: append-only logs, evidence that survives review, and a refusal to ship a control that cannot prove it ran. Every engagement is personally led. My own operating stack, agents, loops, handoffs and all, runs the way this page describes.
Every engagement starts with a written Architecture Review: $3,500, five business days. Hire me on a retainer within 60 days and the full $3,500 comes off your first month, so the review costs you nothing. If the honest answer is that you should stay on a commercial API, I will say so in writing, refund the $3,500 in full, and you keep the review.
Your workflows, data constraints and volume, and the honest answer on local versus API, pipeline versus loop versus agent.
Scoped on what I own for you, not on days per week. Billed monthly with a 90-day initial commitment, then month to month. You keep every model, prompt, eval and line of infrastructure code on every tier.