BranchesTags

Repository files navigation

Hartlib

Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.

What makes it different

  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.

Who it serves

Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.

Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.

Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness. Website:hartlib.ai

Try it locally

Requirements

  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat

Start the demo

bun install
cp .env.example .env

Set ZAI_API_KEY in .env, then run:

bun run dev:web

Open http://localhost:5173. Check the API at http://localhost:3000/health.

The startup command waits for PostgreSQL, creates the configured database when needed, applies migrations, and then starts the API, worker, and demo together. Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when 5432 is already in use. bun run dev is an alias for the same local demo startup. DATABASE_URL must use a loopback host and an explicit user; the startup process rejects routing query overrides (including the case-insensitive connectionString override), credential-bearing PostgreSQL query parameters, raw ASCII control characters, paths that do not name exactly one database segment (including literal or encoded dot segments), ambiguous encoded URI-reserved characters, and database names above PostgreSQL's 63-byte limit.

The startup database check uses the container's local TCP endpoint and the credentials from DATABASE_URL; the published host port binds to 127.0.0.1 only. Local development orchestration supports macOS and Linux only and rejects Windows before starting Docker or any application process. The canonical DATABASE_URL keeps its supported query options for migrations and apps; the psql maintenance check copies only its explicit libpq connection-option allowlist, so options such as statement_timeout do not enter that URL. See the local development specification for the full option policy.

To let Hartlib search the web, set TINYFISH_API_KEY in .env.

Specifications

License

MIT

About

A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.

hartlib.ai

Resources

Readme
MIT license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Hartlib
Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.
What makes it different
  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.
Who it serves
Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.
Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.
Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness.
Website:hartlib.ai
Try it locally
Requirements
  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat
Start the demo
bun install
cp .env.example .env
Set ZAI_API_KEY in .env, then run:
bun run dev:web
Open http://localhost:5173. Check the API at http://localhost:3000/health.
The startup command waits for PostgreSQL, creates the configured database when
needed, applies migrations, and then starts the API, worker, and demo together.
Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when
5432 is already in use. bun run dev is an alias for the same local demo
startup. DATABASE_URL must use a loopback host and an explicit user; the
startup process rejects routing query overrides (including the case-insensitive
connectionString override), credential-bearing PostgreSQL query parameters,
raw ASCII control characters, paths that do not name exactly one database
segment (including literal or encoded dot segments), ambiguous encoded
URI-reserved characters, and database names above PostgreSQL's 63-byte limit.
The startup database check uses the container's local TCP endpoint and the
credentials from DATABASE_URL; the published host port binds to 127.0.0.1
only. Local development orchestration supports macOS and Linux only and rejects
Windows before starting Docker or any application process. The canonical
DATABASE_URL keeps its supported query options for migrations and apps; the
psql maintenance check copies only its explicit libpq connection-option
allowlist, so options such as statement_timeout do not enter that URL. See
the local development specification
for the full option policy.
To let Hartlib search the web, set TINYFISH_API_KEY in .env.
Specifications
License
MIT
About
A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.
hartlib.ai
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Hartlib
Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.
What makes it different
  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.
Who it serves
Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.
Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.
Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness.
Website:hartlib.ai
Try it locally
Requirements
  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat
Start the demo
bun install
cp .env.example .env
Set ZAI_API_KEY in .env, then run:
bun run dev:web
Open http://localhost:5173. Check the API at http://localhost:3000/health.
The startup command waits for PostgreSQL, creates the configured database when
needed, applies migrations, and then starts the API, worker, and demo together.
Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when
5432 is already in use. bun run dev is an alias for the same local demo
startup. DATABASE_URL must use a loopback host and an explicit user; the
startup process rejects routing query overrides (including the case-insensitive
connectionString override), credential-bearing PostgreSQL query parameters,
raw ASCII control characters, paths that do not name exactly one database
segment (including literal or encoded dot segments), ambiguous encoded
URI-reserved characters, and database names above PostgreSQL's 63-byte limit.
The startup database check uses the container's local TCP endpoint and the
credentials from DATABASE_URL; the published host port binds to 127.0.0.1
only. Local development orchestration supports macOS and Linux only and rejects
Windows before starting Docker or any application process. The canonical
DATABASE_URL keeps its supported query options for migrations and apps; the
psql maintenance check copies only its explicit libpq connection-option
allowlist, so options such as statement_timeout do not enter that URL. See
the local development specification
for the full option policy.
To let Hartlib search the web, set TINYFISH_API_KEY in .env.
Specifications
License
MIT
About
A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.
hartlib.ai
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Hartlib
Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.
What makes it different
  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.
Who it serves
Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.
Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.
Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness.
Website:hartlib.ai
Try it locally
Requirements
  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat
Start the demo
bun install
cp .env.example .env
Set ZAI_API_KEY in .env, then run:
bun run dev:web
Open http://localhost:5173. Check the API at http://localhost:3000/health.
The startup command waits for PostgreSQL, creates the configured database when
needed, applies migrations, and then starts the API, worker, and demo together.
Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when
5432 is already in use. bun run dev is an alias for the same local demo
startup. DATABASE_URL must use a loopback host and an explicit user; the
startup process rejects routing query overrides (including the case-insensitive
connectionString override), credential-bearing PostgreSQL query parameters,
raw ASCII control characters, paths that do not name exactly one database
segment (including literal or encoded dot segments), ambiguous encoded
URI-reserved characters, and database names above PostgreSQL's 63-byte limit.
The startup database check uses the container's local TCP endpoint and the
credentials from DATABASE_URL; the published host port binds to 127.0.0.1
only. Local development orchestration supports macOS and Linux only and rejects
Windows before starting Docker or any application process. The canonical
DATABASE_URL keeps its supported query options for migrations and apps; the
psql maintenance check copies only its explicit libpq connection-option
allowlist, so options such as statement_timeout do not enter that URL. See
the local development specification
for the full option policy.
To let Hartlib search the web, set TINYFISH_API_KEY in .env.
Specifications
License
MIT
About
A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.
hartlib.ai
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Hartlib
Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.
What makes it different
  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.
Who it serves
Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.
Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.
Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness.
Website:hartlib.ai
Try it locally
Requirements
  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat
Start the demo
bun install
cp .env.example .env
Set ZAI_API_KEY in .env, then run:
bun run dev:web
Open http://localhost:5173. Check the API at http://localhost:3000/health.
The startup command waits for PostgreSQL, creates the configured database when
needed, applies migrations, and then starts the API, worker, and demo together.
Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when
5432 is already in use. bun run dev is an alias for the same local demo
startup. DATABASE_URL must use a loopback host and an explicit user; the
startup process rejects routing query overrides (including the case-insensitive
connectionString override), credential-bearing PostgreSQL query parameters,
raw ASCII control characters, paths that do not name exactly one database
segment (including literal or encoded dot segments), ambiguous encoded
URI-reserved characters, and database names above PostgreSQL's 63-byte limit.
The startup database check uses the container's local TCP endpoint and the
credentials from DATABASE_URL; the published host port binds to 127.0.0.1
only. Local development orchestration supports macOS and Linux only and rejects
Windows before starting Docker or any application process. The canonical
DATABASE_URL keeps its supported query options for migrations and apps; the
psql maintenance check copies only its explicit libpq connection-option
allowlist, so options such as statement_timeout do not enter that URL. See
the local development specification
for the full option policy.
To let Hartlib search the web, set TINYFISH_API_KEY in .env.
Specifications
License
MIT
About
A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.
hartlib.ai
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Hartlib
Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.
What makes it different
  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.
Who it serves
Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.
Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.
Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness.
Website:hartlib.ai
Try it locally
Requirements
  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat
Start the demo
bun install
cp .env.example .env
Set ZAI_API_KEY in .env, then run:
bun run dev:web
Open http://localhost:5173. Check the API at http://localhost:3000/health.
The startup command waits for PostgreSQL, creates the configured database when
needed, applies migrations, and then starts the API, worker, and demo together.
Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when
5432 is already in use. bun run dev is an alias for the same local demo
startup. DATABASE_URL must use a loopback host and an explicit user; the
startup process rejects routing query overrides (including the case-insensitive
connectionString override), credential-bearing PostgreSQL query parameters,
raw ASCII control characters, paths that do not name exactly one database
segment (including literal or encoded dot segments), ambiguous encoded
URI-reserved characters, and database names above PostgreSQL's 63-byte limit.
The startup database check uses the container's local TCP endpoint and the
credentials from DATABASE_URL; the published host port binds to 127.0.0.1
only. Local development orchestration supports macOS and Linux only and rejects
Windows before starting Docker or any application process. The canonical
DATABASE_URL keeps its supported query options for migrations and apps; the
psql maintenance check copies only its explicit libpq connection-option
allowlist, so options such as statement_timeout do not enter that URL. See
the local development specification
for the full option policy.
To let Hartlib search the web, set TINYFISH_API_KEY in .env.
Specifications
License
MIT
About
A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.
hartlib.ai
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Hartlib
Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.
What makes it different
  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.
Who it serves
Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.
Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.
Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness.
Website:hartlib.ai
Try it locally
Requirements
  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat
Start the demo
bun install
cp .env.example .env
Set ZAI_API_KEY in .env, then run:
bun run dev:web
Open http://localhost:5173. Check the API at http://localhost:3000/health.
The startup command waits for PostgreSQL, creates the configured database when
needed, applies migrations, and then starts the API, worker, and demo together.
Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when
5432 is already in use. bun run dev is an alias for the same local demo
startup. DATABASE_URL must use a loopback host and an explicit user; the
startup process rejects routing query overrides (including the case-insensitive
connectionString override), credential-bearing PostgreSQL query parameters,
raw ASCII control characters, paths that do not name exactly one database
segment (including literal or encoded dot segments), ambiguous encoded
URI-reserved characters, and database names above PostgreSQL's 63-byte limit.
The startup database check uses the container's local TCP endpoint and the
credentials from DATABASE_URL; the published host port binds to 127.0.0.1
only. Local development orchestration supports macOS and Linux only and rejects
Windows before starting Docker or any application process. The canonical
DATABASE_URL keeps its supported query options for migrations and apps; the
psql maintenance check copies only its explicit libpq connection-option
allowlist, so options such as statement_timeout do not enter that URL. See
the local development specification
for the full option policy.
To let Hartlib search the web, set TINYFISH_API_KEY in .env.
Specifications
License
MIT
About
A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.
hartlib.ai
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
Hartlib
Hartlib gives you one research conversation across everything you subscribe to — professional briefings, specialist publications, official records. Ask in your own words and get one cited answer you can actually understand, explained with visuals that fit how you think.
What makes it different
  1. One chat, many agents. Each question puts several agents to work at once: one selects the earlier messages that matter, another your saved memories, the rest search your sources. You see one answer.
  2. It reads what you don't. Briefings, confidential letters, and official records are dense and scattered; few people read them end to end. Hartlib navigates them for you.
  3. Plain questions. No query syntax, no copying context by hand. Ask as you would ask a colleague. Independent parts of a question are researched in parallel and joined into one answer.
  4. Every answer cited. Claims point to the exact issue, document, or page they came from, and completed answers keep their citations.
  5. Answers you can see. Charts and visualizations grow beside the conversation. With each turn the agent learns which forms make things clearest for you and shapes future visuals accordingly. Today Hartlib returns cited text, summaries, comparisons, and tables; live charts arrive with the visual companion.
Who it serves
Clients work in one continuing conversation over every subscription at once. They read delivered issues, search the archive directly, and share or archive past work without starting over. When allowed, web search joins their sources.
Publishers create private subscriptions, publish issues, invite client companies, and manage delivery. They keep their content and client relationships; their subscribers get a searchable, cited research service over the archive.
Status: Active development. Explore the product in the local demo. Production use is not enabled yet; see Production readiness.
Website:hartlib.ai
Try it locally
Requirements
  • Bun
  • Docker with Compose
  • A Z.AI API key (ZAI_API_KEY) for local AI chat
Start the demo
bun install
cp .env.example .env
Set ZAI_API_KEY in .env, then run:
bun run dev:web
Open http://localhost:5173. Check the API at http://localhost:3000/health.
The startup command waits for PostgreSQL, creates the configured database when
needed, applies migrations, and then starts the API, worker, and demo together.
Set HARTLIB_POSTGRES_HOST_PORT and the matching port in DATABASE_URL when
5432 is already in use. bun run dev is an alias for the same local demo
startup. DATABASE_URL must use a loopback host and an explicit user; the
startup process rejects routing query overrides (including the case-insensitive
connectionString override), credential-bearing PostgreSQL query parameters,
raw ASCII control characters, paths that do not name exactly one database
segment (including literal or encoded dot segments), ambiguous encoded
URI-reserved characters, and database names above PostgreSQL's 63-byte limit.
The startup database check uses the container's local TCP endpoint and the
credentials from DATABASE_URL; the published host port binds to 127.0.0.1
only. Local development orchestration supports macOS and Linux only and rejects
Windows before starting Docker or any application process. The canonical
DATABASE_URL keeps its supported query options for migrations and apps; the
psql maintenance check copies only its explicit libpq connection-option
allowlist, so options such as statement_timeout do not enter that URL. See
the local development specification
for the full option policy.
To let Hartlib search the web, set TINYFISH_API_KEY in .env.
Specifications
License
MIT
About
A single chat for your subscriptions and densest sources: grounded answers, explained the way you understand best.
hartlib.ai
Resources
Readme
MIT license
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Contributors
Languages